diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..59e3a69
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,43 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Test and coverage artifacts
+.pytest_cache/
+.coverage
+.coverage.*
+htmlcov/
+.tox/
+.nox/
+
+# Build and packaging artifacts
+build/
+dist/
+*.egg-info/
+*.egg
+pip-wheel-metadata/
+
+# Virtual environments
+.venv/
+venv/
+env/
+ENV/
+
+# Local environment files
+.env
+.env.*
+!.env.example
+
+# Python tooling caches
+.mypy_cache/
+.ruff_cache/
+.pyre/
+.pytype/
+
+# OS and editor noise
+.DS_Store
+.idea/
+.vscode/
+*.swp
+*.swo
diff --git a/MANIFEST.in b/MANIFEST.in
new file mode 100644
index 0000000..b66320f
--- /dev/null
+++ b/MANIFEST.in
@@ -0,0 +1,9 @@
+global-exclude */__pycache__/*
+global-exclude *.pyc
+global-exclude .pytest_cache/*
+include LICENSE
+include README.md
+include README.zh.md
+recursive-include docs *.md
+recursive-include samples/channel *.py
+prune tests
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..3ba43c1
--- /dev/null
+++ b/README.md
@@ -0,0 +1,75 @@
+# Lark Channel SDK for Python
+
+`lark-channel-sdk` is a Python package for building Feishu and Lark
+conversational bots. It provides `FeishuChannel` as the main entry point for
+event listening, message normalization, policy control, outbound messaging,
+media handling, card callbacks, and streaming replies.
+
+## Install
+
+```bash
+pip install lark-channel-sdk
+```
+
+## Minimal Example
+
+```python
+import asyncio
+import os
+
+from lark_channel import FeishuChannel
+
+channel = FeishuChannel(
+    app_id=os.environ["LARK_APP_ID"],
+    app_secret=os.environ["LARK_APP_SECRET"],
+)
+
+
+async def on_message(msg):
+    await channel.send(
+        msg.chat_id,
+        {"markdown": f"received: {msg.content_text}"},
+        {"reply_to": msg.message_id},
+    )
+
+
+channel.on("message", on_message)
+asyncio.run(channel.connect())
+```
+
+## Documentation
+
+- [Quickstart](docs/quickstart.md)
+- [API reference](docs/reference.md)
+- [Markdown messages](docs/markdown.md)
+- [Webhook server adapter](docs/webhook-server.md)
+- [CardKit streaming](docs/cardkit-streaming.md)
+- [Deduplication architecture](docs/dedup-architecture.md)
+- [Echo bot sample](samples/channel/echo_bot.py)
+
+## Migration from `lark_oapi.channel`
+
+Install the standalone package and update the import path:
+
+```bash
+pip install lark-channel-sdk
+```
+
+```python
+from lark_channel import FeishuChannel
+```
+
+`lark-channel-sdk` can be installed alongside `lark-oapi`. Use
+`lark-channel-sdk` for Channel bot workflows and keep using `lark-oapi` when
+your application needs the full OpenAPI SDK surface.
+
+## Local Development
+
+```bash
+pip install -e ".[test]"
+pytest
+```
+
+## License
+
+This project is licensed under the MIT License. See [LICENSE](LICENSE).
diff --git a/README.zh.md b/README.zh.md
new file mode 100644
index 0000000..ad2c699
--- /dev/null
+++ b/README.zh.md
@@ -0,0 +1,73 @@
+# Lark Channel Python SDK
+
+`lark-channel-sdk` 是用于构建飞书和 Lark 会话式机器人的 Python 包。它以
+`FeishuChannel` 为主要入口，封装事件监听、消息归一化、策略控制、出站消息、
+媒体处理、卡片回调和流式回复。
+
+## 安装
+
+```bash
+pip install lark-channel-sdk
+```
+
+## 最小示例
+
+```python
+import asyncio
+import os
+
+from lark_channel import FeishuChannel
+
+channel = FeishuChannel(
+    app_id=os.environ["LARK_APP_ID"],
+    app_secret=os.environ["LARK_APP_SECRET"],
+)
+
+
+async def on_message(msg):
+    await channel.send(
+        msg.chat_id,
+        {"markdown": f"received: {msg.content_text}"},
+        {"reply_to": msg.message_id},
+    )
+
+
+channel.on("message", on_message)
+asyncio.run(channel.connect())
+```
+
+## 文档
+
+- [快速开始](docs/quickstart.md)
+- [API 参考](docs/reference.md)
+- [Markdown 消息](docs/markdown.md)
+- [Webhook 服务适配](docs/webhook-server.md)
+- [CardKit 流式回复](docs/cardkit-streaming.md)
+- [去重架构](docs/dedup-architecture.md)
+- [Echo bot 示例](samples/channel/echo_bot.py)
+
+## 从 `lark_oapi.channel` 迁移
+
+安装独立包并更新 import 路径：
+
+```bash
+pip install lark-channel-sdk
+```
+
+```python
+from lark_channel import FeishuChannel
+```
+
+`lark-channel-sdk` 可以与 `lark-oapi` 安装在同一环境中。Channel bot 工作流使用
+`lark-channel-sdk`；如果应用需要完整 OpenAPI SDK 能力，继续使用 `lark-oapi`。
+
+## 本地开发
+
+```bash
+pip install -e ".[test]"
+pytest
+```
+
+## 许可证
+
+本项目使用 MIT License，详见 [LICENSE](LICENSE)。
diff --git a/docs/cardkit-streaming.md b/docs/cardkit-streaming.md
new file mode 100644
index 0000000..e8faf9e
--- /dev/null
+++ b/docs/cardkit-streaming.md
@@ -0,0 +1,139 @@
+# Streaming with CardKit
+
+For normal markdown streaming, prefer the high-level `channel.stream(...)`
+helper:
+
+```python
+async def produce(stream):
+    for chunk in ["hello", " ", "world"]:
+        await stream.append(chunk)
+
+await channel.stream(chat_id, {"markdown": produce}, {"reply_to": message_id})
+```
+
+`channel.stream(...)` owns CardKit preallocation, throttling, cancellation
+handling, and the final `finish_streaming_card(...)` call. Use the lower-level
+methods below only when you need custom CardKit control.
+
+## Low-level APIs
+
+| Method | Purpose |
+|---|---|
+| `await channel.create_card_instance(spec)` | Allocate a `card_id` from a card JSON spec |
+| `await channel.send_card_by_reference(to, card_id, ...)` | Send a message that points to the preallocated card |
+| `await channel.update_card_element_content(card_id, element_id, content, sequence)` | Patch one element's text during streaming |
+| `await channel.finish_streaming_card(card_id, sequence)` | Close `streaming_mode` so users see the final card |
+
+The high-level `channel.stream(..., {"markdown": producer}, ...)` path wraps
+these methods through `MarkdownStreamController` and is the recommended public
+API for token streaming.
+
+## Required Permissions
+
+A bot must have the required message and CardKit scopes enabled before calling
+CardKit APIs. Scope names can vary by tenant UI; verify the exact names in the
+Feishu developer console.
+
+| Scope name (zh-CN) | Scope ID | Used by |
+|---|---|---|
+| 发送消息 | `im:message:send_as_bot` | `send_card_by_reference` |
+| 获取与发送单聊、群组消息 | `im:message` | Inbound and outbound message operations |
+| 创建卡片实体 | `cardkit:card:write` | `create_card_instance` |
+| 更新卡片实体 | `cardkit:card` | `update_card_element_content`, `finish_streaming_card` |
+
+If your tenant still exposes the legacy `cardkit:card:read` /
+`cardkit:card:update` split, enable both. After changing scopes, re-install the
+bot into the tenant; existing tokens do not pick up new scopes.
+
+## Sequence Semantics
+
+`update_card_element_content(card_id, element_id, content, sequence)` carries a
+strictly increasing `sequence` number per `card_id`.
+
+- The first patch must have `sequence >= 1`.
+- Each subsequent patch must have `sequence >` the previous one.
+- Gaps are allowed, for example `1, 3, 5`.
+- `finish_streaming_card(card_id, sequence)` follows the same rule: its
+  `sequence` must exceed the largest sequence used in any update call for that
+  card.
+
+Recommended pattern:
+
+```python
+seq = 0
+
+async def patch(text):
+    nonlocal seq
+    seq += 1
+    await channel.update_card_element_content(card_id, "main", text, sequence=seq)
+
+# ... stream tokens, calling patch() ...
+
+seq += 1
+await channel.finish_streaming_card(card_id, sequence=seq)
+```
+
+## `finish_streaming_card` vs `update_card`
+
+These methods are not interchangeable.
+
+| Method | When to use | What it does |
+|---|---|---|
+| `finish_streaming_card(card_id, sequence)` | Streaming output complete | Sets `config.streaming_mode = false` on the preallocated card. |
+| `update_card(message_id, card)` | One-shot card replacement | Replaces the whole card payload of a sent message. Uses `message_id`, not `card_id`, and has no `sequence`. |
+
+If you need to update a card after `finish_streaming_card`, use
+`update_card(message_id, card)` with the `message_id` returned from
+`send_card_by_reference(...)`, not the `card_id`.
+
+## API Error Hints
+
+Low-level CardKit methods raise `FeishuChannelError(code=unknown, ...)` for
+non-zero CardKit responses in this release. Inspect the raw API response inside
+the exception message and use the upstream API code as a troubleshooting hint.
+
+| API code | Likely cause | Fix |
+|---|---|---|
+| `99991672` / `99991679` | Missing create-card scope | Add scope and re-install bot |
+| `99991680` / `99991681` | Missing update-card scope | Add scope and re-install bot |
+| `230099` | `sequence` regressed or was reused | Reset the stream and allocate a new `card_id` |
+| `230001` | Card JSON spec malformed | Validate against CardKit 2.0 schema |
+| `230002` / `230020` | Card already finished, or message recalled | Allocate a new `card_id` |
+
+## Core Flow Example
+
+This snippet focuses on the CardKit calls. It assumes `channel` is already
+connected and `chat_id` is known.
+
+```python
+card_id = await channel.create_card_instance({
+    "schema": "2.0",
+    "config": {"streaming_mode": True, "summary": {"content": ""}},
+    "body": {
+        "elements": [
+            {"tag": "markdown", "element_id": "main", "content": "..."},
+        ],
+    },
+})
+
+send_result = await channel.send_card_by_reference(chat_id, card_id)
+if not send_result.success:
+    raise RuntimeError(send_result.error)
+
+seq = 0
+accumulated = ""
+for token in ["hello", " ", "world"]:
+    accumulated += token
+    seq += 1
+    await channel.update_card_element_content(
+        card_id,
+        "main",
+        accumulated,
+        sequence=seq,
+    )
+
+seq += 1
+await channel.finish_streaming_card(card_id, sequence=seq)
+```
+
+Return to the [project README](../README.md).
diff --git a/docs/dedup-architecture.md b/docs/dedup-architecture.md
new file mode 100644
index 0000000..7d3285a
--- /dev/null
+++ b/docs/dedup-architecture.md
@@ -0,0 +1,202 @@
+# Channel SDK: Two-layer Dedup Architecture
+
+This document is an advanced architecture note for applications that need to
+customize Channel dedup state. Most bots can use the defaults.
+
+Channel has two dedup layers:
+
+1. **Pipeline layer**: `InboundPipeline` uses a `DedupStore` before full message
+   normalization. It catches webhook retries and WebSocket reconnect backfill.
+2. **Safety layer**: `SafetyPipeline` uses `SeenCache` before dispatching to
+   user handlers. It catches duplicate handler dispatches and can optionally
+   consult a shared `ICache`.
+
+The two layers use different protocols because they run at different points in
+the pipeline.
+
+## Pipeline Layer: `DedupStore`
+
+`DedupStore` is defined in `lark_channel.channel.normalize.dedup` and re-exported
+from `lark_channel.channel`.
+
+```python
+from typing import Protocol, runtime_checkable
+
+@runtime_checkable
+class DedupStore(Protocol):
+    def seen(self, key: str) -> bool: ...
+    def mark(self, key: str, ttl_seconds: int) -> None: ...
+```
+
+Contract:
+
+- `seen(key)` returns `True` if the key is still considered seen.
+- `mark(key, ttl_seconds)` records the key with the TTL supplied by the SDK.
+- Implementations should be thread-safe.
+- TTL behavior is part of the protocol. Capacity limits and LRU eviction are
+  implementation choices, not SDK-enforced protocol methods.
+
+Key helpers:
+
+```python
+from lark_channel import make_event_key, make_message_key
+
+make_event_key("cli_xxx", "evt_xxx")    # "evt:cli_xxx:evt_xxx"
+make_message_key("cli_xxx", "om_xxx")   # "msg:cli_xxx:om_xxx"
+```
+
+Inject a custom store with `dedup_store=...`:
+
+```python
+from lark_channel import FeishuChannel
+
+channel = FeishuChannel(
+    app_id="cli_xxx",
+    app_secret="***",
+    dedup_store=my_dedup_store,
+)
+```
+
+## Safety Layer: `ICache`
+
+`SeenCache` can use an optional `lark_channel.core.cache.ICache` implementation.
+The current `ICache` interface is synchronous:
+
+```python
+class ICache:
+    def get(self, key: str) -> str: ...
+    def set(self, key: str, value: str, expire: int): ...
+```
+
+`expire` is a Unix timestamp in seconds.
+
+The current `ICache` does not expose an atomic `SETNX` primitive. With multiple
+workers, shared-cache dedup is best-effort rather than a strict cross-process
+coherence boundary. Safe patterns:
+
+- Route events for one app to a single worker.
+- Make handlers idempotent on event/message ids.
+
+Inject a shared cache with `safety_cache=...`:
+
+```python
+from lark_channel import FeishuChannel
+
+channel = FeishuChannel(
+    app_id="cli_xxx",
+    app_secret="***",
+    safety_cache=my_cache,
+)
+```
+
+## Configuration Notes
+
+`DedupConfig.ttl_seconds`, `max_entries`, and `sweep_seconds` are used by the
+default in-memory stores. When you pass a custom `dedup_store`, the SDK only
+passes `ttl_seconds` into `mark(key, ttl_seconds)`; your store owns any capacity
+and eviction behavior.
+
+In this release, `DedupConfig.enabled` controls the pipeline-layer `Deduper`.
+The safety layer still runs `SeenCache` dedup.
+
+```python
+from lark_channel import DedupConfig, FeishuChannel, SafetyConfig
+
+channel = FeishuChannel(
+    app_id="cli_xxx",
+    app_secret="***",
+    safety=SafetyConfig(
+        dedup=DedupConfig(
+            ttl_seconds=12 * 3600,
+            max_entries=5000,
+            sweep_seconds=5 * 60,
+        ),
+    ),
+)
+```
+
+## Example: JSON File Store
+
+This example persists pipeline-layer dedup state across process restarts. It is
+not shipped as an SDK class.
+
+```python
+import json
+import threading
+import time
+from collections import OrderedDict
+from pathlib import Path
+
+class JsonFileDedupStore:
+    def __init__(self, path: Path, *, max_entries: int = 5000) -> None:
+        self._path = Path(path)
+        self._max = max_entries
+        self._lock = threading.Lock()
+        self._data = OrderedDict()
+        self._load()
+
+    def _load(self) -> None:
+        if not self._path.exists():
+            return
+        try:
+            raw = json.loads(self._path.read_text())
+            now = time.time()
+            self._data = OrderedDict(
+                (k, exp)
+                for k, exp in raw.items()
+                if isinstance(exp, (int, float)) and exp > now
+            )
+        except (json.JSONDecodeError, OSError):
+            self._data = OrderedDict()
+
+    def _persist_locked(self) -> None:
+        tmp = self._path.with_suffix(self._path.suffix + ".tmp")
+        tmp.parent.mkdir(parents=True, exist_ok=True)
+        tmp.write_text(json.dumps(dict(self._data)))
+        tmp.replace(self._path)
+
+    def seen(self, key: str) -> bool:
+        with self._lock:
+            exp = self._data.get(key)
+            if exp is None:
+                return False
+            if exp <= time.time():
+                self._data.pop(key, None)
+                return False
+            self._data.move_to_end(key)
+            return True
+
+    def mark(self, key: str, ttl_seconds: int) -> None:
+        with self._lock:
+            self._data[key] = time.time() + ttl_seconds
+            self._data.move_to_end(key)
+            while len(self._data) > self._max:
+                self._data.popitem(last=False)
+            self._persist_locked()
+```
+
+## Example: Redis `ICache`
+
+This example adapts Redis to the safety-layer `ICache` shape. It is
+best-effort because the SDK calls `get()` and `set()` separately.
+
+```python
+import time
+
+import redis
+
+class RedisICache:
+    def __init__(self, client: redis.Redis, *, prefix: str = "feishu:seen:") -> None:
+        self._client = client
+        self._prefix = prefix
+
+    def get(self, key: str):
+        value = self._client.get(self._prefix + key)
+        return value.decode() if value else None
+
+    def set(self, key: str, value: str, expire: int):
+        ttl = max(1, int(expire - time.time()))
+        self._client.set(self._prefix + key, value, ex=ttl)
+```
+
+Return to the [project README](../README.md).
diff --git a/docs/markdown.md b/docs/markdown.md
new file mode 100644
index 0000000..2b034e6
--- /dev/null
+++ b/docs/markdown.md
@@ -0,0 +1,116 @@
+# Markdown to Post Conversion
+
+Channel sends `{"markdown": ...}` and bare string messages as Feishu post
+messages. The SDK converts markdown into a post AST before calling the message
+API.
+
+If you want a plain text message, send `{"text": "..."}` explicitly.
+
+## Configuration
+
+```python
+from lark_channel import FeishuChannel, MarkdownConverter, OutboundConfig
+
+channel = FeishuChannel(
+    app_id="cli_xxx",
+    app_secret="***",
+    outbound=OutboundConfig(
+        markdown_converter=MarkdownConverter(tag_md_mode="native"),
+    ),
+)
+```
+
+## Modes
+
+| Mode | When to use | Rendering behavior |
+|---|---|---|
+| `structured` (default) | Deterministic rendering across clients, code blocks, links, and SDK-side wire-format assertions | Parses markdown into explicit post nodes such as `tag:text`, `tag:a`, and `tag:code_block`. Feishu post has no native heading, blockquote, or nested-list nodes, so those constructs are flattened or approximated. |
+| `native` | Richer user-facing markdown rendering in Feishu clients | Wraps markdown into `tag:md` nodes and lets the Feishu client render it. Headings, quotes, and lists render closer to native markdown, but exact output depends on client version. |
+
+`MarkdownConverter.enabled` exists for compatibility with the config schema. Do
+not rely on `enabled=False` to send plain text; use `{"text": ...}` instead.
+
+## Choosing a Mode
+
+- Use `structured` when you need predictable cross-client output or testable
+  post ASTs.
+- Use `native` when user-facing markdown structure matters more than exact
+  cross-client parity.
+- Use `{"text": ...}` for plain text.
+
+## Native Mode Notes
+
+- Rendering is delegated to the Feishu client markdown parser.
+- `OutboundPost(post=prebuilt_ast)` is passed through and is not affected by
+  `tag_md_mode`.
+- Structured mentions are inserted as post `tag:at` nodes in the first row.
+  They are not written as literal `<at>` text inside a `tag:md` string.
+
+## Wire Format Comparison
+
+Input:
+
+````
+# Hello
+
+> world
+
+```python
+print("hi")
+```
+````
+
+`tag_md_mode="structured"`:
+
+```json
+{"zh_cn": {"title": "", "content": [
+  [{"tag": "text", "text": "Hello", "style": ["bold"]}],
+  [{"tag": "text", "text": "│ "}, {"tag": "text", "text": "world"}],
+  [{"tag": "code_block", "language": "PYTHON", "text": "print(\"hi\")"}]
+]}}
+```
+
+`tag_md_mode="native"`:
+
+```json
+{"zh_cn": {"title": "", "content": [
+  [{"tag": "md", "text": "# Hello\n\n> world\n"}],
+  [{"tag": "md", "text": "```python\nprint(\"hi\")\n```"}]
+]}}
+```
+
+## Editing Messages
+
+`FeishuChannel.edit_message(message_id, message)` accepts the same high-level
+outbound shapes as `send()` for editable text/post messages:
+
+```python
+await channel.edit_message(message_id, "# Markdown heading")
+await channel.edit_message(message_id, {"markdown": "**bold**"})
+await channel.edit_message(message_id, {"text": "plain text"})
+await channel.edit_message(message_id, {"post": prebuilt_post_ast})
+```
+
+Cards are updated with `update_card(message_id, card)`, not `edit_message()`.
+Media, share, and sticker messages are not editable through `edit_message()`.
+
+## Image and Video Captions
+
+Images and videos can include an optional markdown caption:
+
+```python
+await channel.send(chat_id, {"image": {"source": image_url}, "caption": "Generated screenshot"})
+await channel.send(chat_id, {"video": {"source": video_bytes}, "caption": "Demo clip"})
+```
+
+When no caption is provided, image/video messages use the normal `image` or
+`media` message type. With a caption, the SDK sends a single post message that
+contains the rendered caption followed by an image or video node. Caption
+markdown follows `OutboundConfig.markdown_converter`.
+
+In this release, captions are supported for image and video messages only.
+`caption` on file or audio dictionary inputs is rejected with `format_error`
+before upload. Send the caption as a separate message if two-message semantics
+are acceptable.
+
+Return to the [project README](../README.md).
diff --git a/docs/quickstart.md b/docs/quickstart.md
new file mode 100644
index 0000000..147303a
--- /dev/null
+++ b/docs/quickstart.md
@@ -0,0 +1,153 @@
+# Channel Quickstart
+
+This guide gets a minimal Channel echo bot running. For the full API surface,
+see the [Channel reference](./reference.md).
+
+## Install
+
+```bash
+pip install lark-channel-sdk
+```
+
+## Prepare the Bot
+
+In the Feishu developer console:
+
+- Create a bot application.
+- Enable event subscriptions.
+- Enable the WebSocket event subscription channel for local development.
+- Subscribe to message receive events.
+- Grant bot message send/receive scopes such as `im:message` and
+  `im:message:send_as_bot`.
+- Re-install the app into the tenant after changing scopes.
+
+Export credentials before running:
+
+```bash
+export LARK_APP_ID=cli_xxx
+export LARK_APP_SECRET=your_app_secret
+```
+
+## Run the Echo Bot
+
+```bash
+python samples/channel/echo_bot.py
+```
+
+The sample is intentionally small:
+
+```python
+import asyncio
+import os
+
+from lark_channel import FeishuChannel
+
+channel = FeishuChannel(
+    app_id=os.environ["LARK_APP_ID"],
+    app_secret=os.environ["LARK_APP_SECRET"],
+)
+
+async def on_message(msg):
+    await channel.send(
+        msg.chat_id,
+        {"text": f"echo: {msg.content_text}"},
+    )
+
+channel.on("message", on_message)
+
+asyncio.run(channel.connect())
+```
+
+`connect()` starts the WebSocket transport and keeps the process running. Use
+`await channel.disconnect()` during graceful shutdown if your application owns
+the event loop.
+
+Register an error handler when you want centralized observability:
+
+```python
+async def on_error(err):
+    print("channel error:", err)
+
+channel.on("error", on_error)
+```
+
+## Send a Reply
+
+```python
+await channel.send(
+    msg.chat_id,
+    {"markdown": f"received: {msg.content_text}"},
+    {"reply_to": msg.message_id},
+)
+```
+
+`channel.send(to, message, opts=None)` accepts dict inputs, typed `Outbound*`
+dataclasses, or a bare markdown string.
+
+## Stream a Reply
+
+```python
+async def produce(stream):
+    for token in ["hello", " ", "world"]:
+        await stream.append(token)
+
+await channel.stream(
+    msg.chat_id,
+    {"markdown": produce},
+    {"reply_to": msg.message_id},
+)
+```
+
+For lower-level CardKit controls, see [Streaming with CardKit](./cardkit-streaming.md).
+
+## Webhook Transport
+
+For HTTP callbacks, construct the channel with `transport="webhook"` and pass
+each HTTP request to `handle_webhook_request(headers, body)`.
+
+```bash
+pip install "lark-channel-sdk[aiohttp]"
+```
+
+```python
+from aiohttp import web
+from lark_channel import FeishuChannel
+
+channel = FeishuChannel(
+    app_id="cli_xxx",
+    app_secret="***",
+    encrypt_key="...",
+    verification_token="...",
+    transport="webhook",
+)
+
+async def on_message(msg):
+    await channel.send(msg.chat_id, {"text": f"echo: {msg.content_text}"})
+
+channel.on("message", on_message)
+
+async def webhook(request):
+    status, body = await channel.handle_webhook_request(
+        headers=dict(request.headers),
+        body=await request.read(),
+    )
+    return web.Response(status=status, body=body, content_type="application/json")
+
+async def init():
+    app = web.Application()
+    app.router.add_post("/feishu/webhook", webhook)
+    await channel.connect_until_ready()
+    return app
+
+web.run_app(init())
+```
+
+The SDK does not ship a built-in HTTP server. Keep TLS termination, rate
+limiting, IP allowlisting, and anomaly tracking in your web framework or
+gateway layer. See [Webhook server adapter](./webhook-server.md).
+
+## Next Steps
+
+- [Channel reference](./reference.md)
+- [Markdown to post conversion](./markdown.md)
+- [Two-layer dedup architecture](./dedup-architecture.md)
diff --git a/docs/reference.md b/docs/reference.md
new file mode 100644
index 0000000..d6e84cc
--- /dev/null
+++ b/docs/reference.md
@@ -0,0 +1,343 @@
+# Channel Reference
+
+This is the detailed reference for `FeishuChannel`. For first-run setup, see
+the [Channel quickstart](./quickstart.md).
+
+## Entry Point
+
+```python
+from lark_channel import FeishuChannel
+```
+
+`FeishuChannel` combines WebSocket or webhook event transport, inbound message
+normalization, safety policy, deduplication, outbound sending, media
+upload/download, streaming replies, and card helpers.
+
+Use the lower-level WebSocket client (`lark_channel.ws.client.Client`), the
+`EventDispatcherHandler`, or the OpenAPI `Client` directly when your integration
+only needs raw event dispatch or direct OpenAPI calls.
+
+## Minimal Example
+
+```python
+import asyncio
+import os
+
+from lark_channel import FeishuChannel
+
+channel = FeishuChannel(
+    app_id=os.environ["LARK_APP_ID"],
+    app_secret=os.environ["LARK_APP_SECRET"],
+)
+
+async def on_message(msg):
+    await channel.send(
+        msg.chat_id,
+        {"markdown": f"received: {msg.content_text}"},
+        {"reply_to": msg.message_id},
+    )
+
+channel.on("message", on_message)
+
+asyncio.run(channel.connect())
+```
+
+## Constructor Options
+
+| Option | Required | Description |
+|---|---:|---|
+| `app_id` / `app_secret` | yes | Feishu app credentials |
+| `domain` | no | Feishu, Lark, or custom OpenAPI domain |
+| `log_level` | no | SDK log level |
+| `transport` | no | `"ws"` by default, or `"webhook"` |
+| `encrypt_key` | if configured | Webhook/event decryption key from the developer console |
+| `verification_token` | if configured | Webhook/event verification token from the developer console |
+| `policy` | no | `PolicyConfig` for DM/group admission and mention behavior |
+| `safety` | no | `SafetyConfig` for dedup, stale window, batching, and per-chat queue |
+| `inbound` | no | `InboundConfig` for normalization, media, names, and reaction behavior |
+| `outbound` | no | `OutboundConfig` for chunking, retry, markdown conversion, SSRF, and streaming throttle |
+| `uat` | no | `UATConfig` for user access token device-flow behavior |
+| `security` | no | `SecurityConfig` for compat/audit/strict security behavior, audit logging, token cache fallback, and WebSocket limits |
+| `token_store` | no | Custom user access token store |
+| `dedup_store` | no | Pipeline-layer `DedupStore` |
+| `safety_cache` | no | Safety-layer `ICache` |
+| `name_lookup` | no | Custom `open_id` to display-name resolver |
+| `config` | no | Prebuilt `ChannelConfig`; flat kwargs override touched fields |
+
+```python
+from lark_channel import DedupConfig, FeishuChannel, OutboundConfig, RetryConfig, SafetyConfig
+
+channel = FeishuChannel(
+    app_id="cli_xxx",
+    app_secret="***",
+    safety=SafetyConfig(dedup=DedupConfig(ttl_seconds=12 * 3600)),
+    outbound=OutboundConfig(retry=RetryConfig(max_attempts=5)),
+)
+```
+
+## Lifecycle
+
+| Method | Purpose |
+|---|---|
+| `await channel.connect()` | Start transport. In WebSocket mode, keep running until stopped. |
+| `await channel.connect_until_ready(timeout=30)` | Start in the background and return after readiness. |
+| `await channel.start_background(timeout=30)` | Alias-style background startup with explicit naming. |
+| `await channel.disconnect()` | Drain safety batches and stop the transport. |
+| `channel.start()` | Synchronous startup. In webhook mode, build the dispatcher and return. |
+| `channel.stop()` | Synchronous teardown. |
+| `await channel.wait_ready(timeout=30)` | Wait for readiness after startup. |
+
+`start()` is synchronous and may block during initial setup, including bot
+identity resolution. Prefer `connect_until_ready()` in async web framework
+startup hooks.
+
+## Event Listening
+
+```python
+from lark_channel import Events
+
+channel.on(Events.MESSAGE, on_message)
+channel.on(Events.CARD_ACTION, on_card_action)
+channel.on(Events.REACTION, on_reaction)
+channel.on(Events.BOT_ADDED, on_bot_added)
+channel.on(Events.BOT_LEAVE, on_bot_leave)
+channel.on(Events.MESSAGE_READ, on_message_read)
+channel.on(Events.COMMENT, on_comment)
+channel.on(Events.REJECT, on_reject)
+channel.on(Events.RECONNECTING, on_reconnecting)
+channel.on(Events.RECONNECTED, on_reconnected)
+channel.on(Events.ERROR, on_error)
+```
+
+Dispatched event names:
+
+| Event | Payload |
+|---|---|
+| `message` | `InboundMessage` |
+| `cardAction` | `CardActionEvent` |
+| `reaction` | `ReactionEvent` |
+| `botAdded` | `BotAddedEvent` |
+| `botLeave` | `BotLeaveEvent` |
+| `messageRead` | `MessageReadEvent` |
+| `comment` | `CommentEvent` |
+| `reject` | `RejectEvent` |
+| `reconnecting` | no argument |
+| `reconnected` | no argument |
+| `error` | exception or `OutboundSendError` |
+
+Snake-case aliases such as `card_action`, `bot_added`, `bot_leave`, and
+`message_read` are normalized for compatibility.
+
+## Message Model
+
+`message` handlers receive an `InboundMessage`.
+
+| Field | Description |
+|---|---|
+| `message_id` / `id` | Feishu message id |
+| `create_time` | Original event timestamp |
+| `conversation` | `Conversation(chat_id, chat_type, thread_id)` |
+| `chat_id` | Shortcut for `conversation.chat_id` |
+| `chat_type` | `p2p`, `group`, `topic`, or `unknown` |
+| `sender` | `Identity` for the sender |
+| `sender_id` | Shortcut for `sender.open_id` |
+| `sender_name` | Optional display name |
+| `mentions` | List of `Mention` objects |
+| `mentioned_all` | Whether the message mentioned all members |
+| `mentioned_bot` | Whether the message mentioned the bot |
+| `reply_to_message_id` | Parent message id when present |
+| `content` | Typed `MessageContent` dataclass |
+| `content_text` | Flattened markdown/XML-style text |
+| `safe_content_text` | Escaped flattened text for security-sensitive rendering |
+| `resources` | Resource descriptors for download |
+| `raw_content_type` | Original Feishu message type |
+| `raw` | Original event payload |
+
+## Security Configuration
+
+`SecurityConfig` defaults to `mode="compat"` to preserve existing behavior.
+Use `mode="audit"` to log security-sensitive legacy behavior without blocking
+it, and `mode="strict"` to enforce stricter checks.
+
+Common options:
+
+| Option | Purpose |
+|---|---|
+| `audit_recorder` | Receives security audit events |
+| `allow_unsigned_encrypted_webhook` | Allows legacy encrypted webhook bodies without a verified signature in strict mode |
+| `allow_insecure_ws` | Allows remote `ws://` WebSocket endpoints in strict mode |
+| `allow_local_insecure_ws` | Allows local `ws://` endpoints, enabled by default for local tests |
+| `strict_error_response` | Uses a generic error response when strict handling is enabled |
+| `strict_content_text` | Makes `content_text` use the escaped text form |
+| `legacy_token_cache_fallback` | Controls fallback to the legacy token cache key |
+| `max_ws_fragment_parts` / `max_ws_fragment_bytes` | Limits fragmented WebSocket payload assembly |
+| `max_concurrent_ws_handlers` | Limits concurrent WebSocket handler tasks |
+| `resource_overflow_policy` | Controls whether oversize normalized resources are audited or dropped |
+
+## Policy
+
+Defaults:
+
+- `dm_policy="open"`
+- `group_policy="open"`
+- `require_mention=True`
+- `respond_to_mention_all=False`
+- `sender_identity_fields=["open_id"]`
+
+Runtime update:
+
+```python
+channel.update_policy(
+    require_mention=False,
+    respond_to_mention_all=True,
+    group_policy="allowlist",
+    group_allowlist=["oc_xxx"],
+)
+```
+
+`update_policy()` accepts keyword changes for fields on `PolicyConfig`.
+
+## Sending Messages
+
+`channel.send(to, message, opts=None)` accepts:
+
+- a bare string, treated as markdown;
+- a dict;
+- a typed `Outbound*` dataclass.
+
+```python
+await channel.send(chat_id, {"text": "plain text"})
+await channel.send(chat_id, {"markdown": "hello **world**"})
+await channel.send(chat_id, {"post": {"zh_cn": {"title": "", "content": []}}})
+await channel.send(chat_id, {"card": {"schema": "2.0", "body": {"elements": []}}})
+await channel.send(chat_id, {"image": {"source": "./image.png"}})
+await channel.send(chat_id, {"file": {"source": b"content", "file_name": "a.txt"}})
+await channel.send(chat_id, {"audio": {"source": "./audio.ogg"}})
+await channel.send(chat_id, {"video": {"source": "./video.mp4"}})
+await channel.send(chat_id, {"share_chat": {"chat_id": "oc_xxx"}})
+await channel.send(chat_id, {"share_user": {"user_id": "ou_xxx"}})
+await channel.send(chat_id, {"sticker": {"file_key": "file_v3_xxx"}})
+```
+
+`opts` may be a `SendOpts` object or a dict:
+
+```python
+await channel.send(
+    chat_id,
+    {"markdown": "please check"},
+    {
+        "reply_to": message_id,
+        "reply_in_thread": True,
+        "receive_id_type": "chat_id",
+        "reply_target_gone": "fresh",
+        "uuid": "optional-idempotency-key",
+    },
+)
+```
+
+For structured mentions, use typed outbound messages:
+
+```python
+from lark_channel import Identity, OutboundText
+
+await channel.send(
+    chat_id,
+    OutboundText(
+        text="please check",
+        mentions=[Identity(open_id="ou_xxx", display_name="Alice")],
+    ),
+)
+```
+
+Media `source` accepts:
+
+- HTTP(S) URL string, guarded by `OutboundConfig.ssrf_allowlist`;
+- local file path string;
+- `bytes`;
+- existing media key string for the matching message kind: `img_...` for
+  images, `file_...` for file/audio/video. Stickers use
+  `{"sticker": {"file_key": ...}}` instead of media `source`.
+
+Image and video messages support `caption`; file and audio captions are rejected
+with `format_error`.
+
+## Streaming
+
+Markdown stream:
+
+```python
+async def producer(stream):
+    for token in ["hello", " ", "world"]:
+        await stream.append(token)
+
+await channel.stream(chat_id, {"markdown": producer}, {"reply_to": message_id})
+```
+
+Card stream:
+
+```python
+async def producer(stream):
+    await stream.update(next_card_json)
+
+await channel.stream(
+    chat_id,
+    {"card": {"initial": initial_card_json, "producer": producer}},
+)
+```
+
+For low-level CardKit preallocation, see [Streaming with CardKit](./cardkit-streaming.md).
+
+## Helpers
+
+| Method | Return | Notes |
+|---|---|---|
+| `await channel.update_card(message_id, card)` | `SendResult` | Replace a sent card message |
+| `await channel.edit_message(message_id, message)` | `SendResult` | Text/post only |
+| `await channel.recall_message(message_id)` | `SendResult` | Recall/delete a message |
+| `await channel.add_reaction(message_id, emoji_type)` | `SendResult` | Add a reaction |
+| `await channel.remove_reaction(message_id, reaction_id)` | `SendResult` | Remove a reaction by id |
+| `await channel.download_resource(file_key, resource_type="image")` | `bytes \| None` | Returns `None` on API failure |
+| `await channel.download_resource_to_file(...)` | `Path` | Raises `download_failed` when no body is returned |
+| `await channel.get_chat_info(chat_id)` | `ChatInfo \| None` | Returns `None` on API failure |
+| `await channel.get_chat_mode(chat_id)` | `str \| None` | Read `chat_mode` with cache and configured fallback |
+| `await channel.resolve_quoted_contexts(messages, chat_mode="group")` | `dict[str, QuoteResolution]` | Resolve quoted parent context for a batch without refetching in-batch parents |
+| `await channel.resolve_resource_to_cache(message_id="om_x", resource=resource)` | `CachedResource` | Download a message resource into the SDK-managed cache |
+| `channel.block_batch_scope(scope)` / `unblock_batch_scope(scope)` / `cancel_batch_scope(scope)` | `None` | Pause, resume, or cancel debounced batches around an active run |
+| `await channel.add_typing_reaction(message_id)` / `remove_typing_reaction(message_id, reaction_id)` | `str \| None` / `bool` | Best-effort IM message `Typing` reaction helpers |
+| `await channel.resolve_comment_target(file_token="doc_x", file_type="docx")` / `get_comment_context(target=target, comment_id="c1")` / `reply_comment(context, "answer")` | `CommentTarget` / `CommentContext` / API result | Cloud document comment primitives for supported `doc`, `docx`, `sheet`, and `file` targets. `reply_comment` creates a whole-file comment when `context.is_whole` is true, or updates an existing reply when `context.target_reply_id` is present. |
+| `channel.client` | `Client` | Underlying OpenAPI client |
+
+## Error Handling
+
+`send()` returns `SendResult`.
+
+- Invalid input and transport/coercion failures may raise.
+- Upstream send failures usually return `SendResult(success=False, error=...)`.
+- Both raised errors and failed `SendResult.error` are forwarded to
+  `channel.on("error", handler)`.
+
+`stream()` and low-level CardKit helpers raise for controller or CardKit
+failures.
+
+Known `FeishuChannelErrorCode` values:
+
+| Code | Meaning |
+|---|---|
+| `format_error` | Message/card schema rejected |
+| `target_revoked` | Reply target no longer accepts replies |
+| `rate_limited` | Upstream rate limit |
+| `permission_denied` | Invalid credentials or missing scopes |
+| `upload_failed` | Media upload failed |
+| `download_failed` | Media download failed |
+| `ssrf_blocked` | URL media download blocked by SSRF policy |
+| `send_timeout` | Send/connect timeout |
+| `not_connected` | Transport is not connected or startup failed |
+| `unknown` | Uncategorized upstream or SDK error |
+
+## Related Documents
+
+- [Channel quickstart](./quickstart.md)
+- [Webhook server adapter](./webhook-server.md)
+- [Streaming with CardKit](./cardkit-streaming.md)
+- [Markdown to post conversion](./markdown.md)
+- [Two-layer dedup architecture](./dedup-architecture.md)
diff --git a/docs/release-notes/v1.0.0.md b/docs/release-notes/v1.0.0.md
new file mode 100644
index 0000000..b80096d
--- /dev/null
+++ b/docs/release-notes/v1.0.0.md
@@ -0,0 +1,37 @@
+# lark-channel-sdk v1.0.0
+
+This is the first standalone release of the Python Channel SDK.
+
+## Highlights
+
+- Standalone package: `lark-channel-sdk`
+- New import path: `lark_channel`
+- High-level `FeishuChannel` entry point
+- WebSocket and webhook event handling
+- Message normalization, send/reply/update/recall/forward
+- Card actions and streaming card updates
+- Media upload/download and media cache primitives
+- Message reactions and typing reaction helpers
+- Cloud document comment context and reply/update helpers for supported `doc`, `docx`, `sheet`, and `file` targets
+
+## Compatibility
+
+- Existing `lark_oapi.channel` users are not forced to migrate immediately.
+- The full OpenAPI SDK remains available from `lark-oapi`.
+- `lark-channel-sdk` is designed to install alongside `lark-oapi`.
+
+## Migration
+
+```bash
+pip install lark-channel-sdk
+```
+
+```python
+from lark_channel import FeishuChannel
+```
+
+## Notes
+
+- Media cache, typing reactions, and cloud document comment helpers require the corresponding Lark app permissions.
+- Cloud document comment helpers cover supported `doc`, `docx`, `sheet`, and `file` comment targets.
+- The full Drive/OpenAPI surface remains in `lark-oapi`.
diff --git a/docs/webhook-server.md b/docs/webhook-server.md
new file mode 100644
index 0000000..de43a76
--- /dev/null
+++ b/docs/webhook-server.md
@@ -0,0 +1,165 @@
+# Webhook Server Adapter
+
+The Channel SDK does not ship a built-in HTTP server. TLS termination, rate
+limiting, IP allowlisting, anomaly tracking, and framework choice belong in
+your application or gateway layer.
+
+Channel exposes one async request entry point:
+
+```python
+status, body_bytes = await channel.handle_webhook_request(headers, body)
+```
+
+`handle_webhook_request(...)` decrypts the body when `encrypt_key` is
+configured, validates `verification_token` when configured, verifies request
+signatures for non-challenge events when `encrypt_key` is configured, and routes
+the event to your registered `channel.on(...)` handlers. Signature headers may
+be present even when event encryption is disabled; without `encrypt_key`, the
+dispatcher treats the request as plaintext and does not verify those headers.
+
+You must initialize the channel before the first request. In async frameworks,
+prefer `await channel.connect_until_ready()` during application startup. The
+synchronous `channel.start()` method is safe in synchronous setup code, but it
+may block while initial setup runs.
+
+## aiohttp Adapter
+
+```bash
+pip install "lark-channel-sdk[aiohttp]"
+```
+
+```python
+from aiohttp import web
+
+from lark_channel import FeishuChannel
+
+channel = FeishuChannel(
+    app_id="cli_xxx",
+    app_secret="***",
+    encrypt_key="...",
+    verification_token="...",
+    transport="webhook",
+)
+
+async def on_message(msg):
+    await channel.send(msg.chat_id, {"text": f"echo: {msg.content_text}"})
+
+channel.on("message", on_message)
+
+async def webhook(request: web.Request) -> web.Response:
+    status, body_bytes = await channel.handle_webhook_request(
+        headers=dict(request.headers),
+        body=await request.read(),
+    )
+    return web.Response(status=status, body=body_bytes, content_type="application/json")
+
+async def init() -> web.Application:
+    app = web.Application()
+    app.router.add_post("/feishu/webhook", webhook)
+    await channel.connect_until_ready()
+    return app
+
+if __name__ == "__main__":
+    web.run_app(init(), host="127.0.0.1", port=8765)
+```
+
+## FastAPI Adapter
+
+```bash
+pip install "lark-channel-sdk[fastapi]"
+```
+
+```python
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI, Request, Response
+
+from lark_channel import FeishuChannel
+
+channel = FeishuChannel(
+    app_id="cli_xxx",
+    app_secret="***",
+    encrypt_key="...",
+    verification_token="...",
+    transport="webhook",
+)
+
+async def on_message(msg):
+    await channel.send(msg.chat_id, {"text": f"echo: {msg.content_text}"})
+
+channel.on("message", on_message)
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    await channel.connect_until_ready()
+    try:
+        yield
+    finally:
+        await channel.disconnect()
+
+app = FastAPI(lifespan=lifespan)
+
+@app.post("/feishu/webhook")
+async def webhook(request: Request):
+    status, body_bytes = await channel.handle_webhook_request(
+        headers=dict(request.headers),
+        body=await request.body(),
+    )
+    return Response(status_code=status, content=body_bytes, media_type="application/json")
+```
+
+## Synchronous Setup
+
+If your framework has synchronous startup code and you are in webhook mode,
+`channel.start()` builds the dispatcher and returns after initial setup:
+
+```python
+channel = FeishuChannel(
+    app_id="cli_xxx",
+    app_secret="***",
+    transport="webhook",
+)
+channel.start()
+```
+
+Do not call `handle_webhook_request(...)` before startup, or it raises
+`FeishuChannelError(code=not_connected)`.
+
+## Rate Limiting and Anomaly Tracking
+
+These belong in your web layer's middleware. For aiohttp:
+
+```python
+from collections import defaultdict
+from time import time
+
+from aiohttp import web
+
+WINDOW_S = 60
+MAX_REQ = 120
+_buckets = defaultdict(list)
+
+@web.middleware
+async def rate_limit(request, handler):
+    ip = request.remote or ""
+    now = time()
+    bucket = _buckets[ip]
+    bucket[:] = [t for t in bucket if t > now - WINDOW_S]
+    if len(bucket) >= MAX_REQ:
+        return web.Response(status=429, text="rate limited")
+    bucket.append(now)
+    return await handler(request)
+
+app = web.Application(middlewares=[rate_limit])
+```
+
+For anomaly tracking, wrap the handler and track non-200 responses per IP or
+tenant key. The SDK only sees validated request bytes and event payloads.
+
+## Why No Built-in Server?
+
+- Avoid forcing aiohttp, FastAPI, or another framework into every SDK user.
+- Production deployments usually already have ingress, WAF, and monitoring.
+- A framework adapter is small and keeps ownership of HTTP concerns clear.
+
+Return to the [project README](../README.md).
diff --git a/lark_channel/__init__.py b/lark_channel/__init__.py
new file mode 100644
index 0000000..355bc85
--- /dev/null
+++ b/lark_channel/__init__.py
@@ -0,0 +1,40 @@
+from .client import Client
+from .core import *
+from .event.context import EventContext
+from .event.custom import CustomizedEvent
+from .event.dispatcher_handler import EventDispatcherHandler
+from .channel import *
+from .channel import (
+    CachedResource,
+    ChatModeCacheConfig,
+    CommentContext,
+    CommentTarget,
+    FeishuChannel,
+    KeepaliveConfig,
+    MediaCacheConfig,
+    QuotedContext,
+    QuoteResolution,
+)
+
+__all__ = [
+    "CachedResource",
+    "ChatModeCacheConfig",
+    "Client",
+    "CommentContext",
+    "CommentTarget",
+    "EventContext",
+    "CustomizedEvent",
+    "EventDispatcherHandler",
+    "FeishuChannel",
+    "KeepaliveConfig",
+    "MediaCacheConfig",
+    "QuotedContext",
+    "QuoteResolution",
+]
+
+try:
+    from .channel import __all__ as _channel_all
+
+    __all__.extend(name for name in _channel_all if name not in __all__)
+except Exception:
+    pass
diff --git a/lark_channel/api/__init__.py b/lark_channel/api/__init__.py
new file mode 100644
index 0000000..0cb8bd8
--- /dev/null
+++ b/lark_channel/api/__init__.py
@@ -0,0 +1,3 @@
+"""Minimal OpenAPI closure used by lark_channel."""
+
+__all__ = ["im", "contact", "cardkit", "drive", "wiki"]
diff --git a/lark_channel/api/cardkit/__init__.py b/lark_channel/api/cardkit/__init__.py
new file mode 100644
index 0000000..326cdf4
--- /dev/null
+++ b/lark_channel/api/cardkit/__init__.py
@@ -0,0 +1 @@
+from . import v1
diff --git a/lark_channel/api/cardkit/service.py b/lark_channel/api/cardkit/service.py
new file mode 100644
index 0000000..efb7755
--- /dev/null
+++ b/lark_channel/api/cardkit/service.py
@@ -0,0 +1,7 @@
+from lark_channel.core.model import Config
+from .v1.version import V1
+
+
+class CardkitService(object):
+    def __init__(self, config: Config) -> None:
+        self.v1: V1 = V1(config)
diff --git a/lark_channel/api/cardkit/v1/__init__.py b/lark_channel/api/cardkit/v1/__init__.py
new file mode 100644
index 0000000..85573ca
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/__init__.py
@@ -0,0 +1,5 @@
+"""Minimal CardKit v1 resources required by lark_channel."""
+
+from .version import V1
+
+__all__ = ["V1"]
diff --git a/lark_channel/api/cardkit/v1/model/__init__.py b/lark_channel/api/cardkit/v1/model/__init__.py
new file mode 100644
index 0000000..7a00a4f
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/__init__.py
@@ -0,0 +1 @@
+"""CardKit model submodules are imported explicitly by lark_channel."""
diff --git a/lark_channel/api/cardkit/v1/model/batch_update_card_request.py b/lark_channel/api/cardkit/v1/model/batch_update_card_request.py
new file mode 100644
index 0000000..4d543eb
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/batch_update_card_request.py
@@ -0,0 +1,38 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .batch_update_card_request_body import BatchUpdateCardRequestBody
+
+
+class BatchUpdateCardRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.card_id: Optional[str] = None
+        self.request_body: Optional[BatchUpdateCardRequestBody] = None
+
+    @staticmethod
+    def builder() -> "BatchUpdateCardRequestBuilder":
+        return BatchUpdateCardRequestBuilder()
+
+
+class BatchUpdateCardRequestBuilder(object):
+
+    def __init__(self) -> None:
+        batch_update_card_request = BatchUpdateCardRequest()
+        batch_update_card_request.http_method = HttpMethod.POST
+        batch_update_card_request.uri = "/open-apis/cardkit/v1/cards/:card_id/batch_update"
+        batch_update_card_request.token_types = {AccessTokenType.TENANT}
+        self._batch_update_card_request: BatchUpdateCardRequest = batch_update_card_request
+
+    def card_id(self, card_id: str) -> "BatchUpdateCardRequestBuilder":
+        self._batch_update_card_request.card_id = card_id
+        self._batch_update_card_request.paths["card_id"] = str(card_id)
+        return self
+
+    def request_body(self, request_body: BatchUpdateCardRequestBody) -> "BatchUpdateCardRequestBuilder":
+        self._batch_update_card_request.request_body = request_body
+        self._batch_update_card_request.body = request_body
+        return self
+
+    def build(self) -> BatchUpdateCardRequest:
+        return self._batch_update_card_request
diff --git a/lark_channel/api/cardkit/v1/model/batch_update_card_request_body.py b/lark_channel/api/cardkit/v1/model/batch_update_card_request_body.py
new file mode 100644
index 0000000..6879451
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/batch_update_card_request_body.py
@@ -0,0 +1,40 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class BatchUpdateCardRequestBody(object):
+    _types = {
+        "uuid": str,
+        "sequence": int,
+        "actions": str,
+    }
+
+    def __init__(self, d=None):
+        self.uuid: Optional[str] = None
+        self.sequence: Optional[int] = None
+        self.actions: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "BatchUpdateCardRequestBodyBuilder":
+        return BatchUpdateCardRequestBodyBuilder()
+
+
+class BatchUpdateCardRequestBodyBuilder(object):
+    def __init__(self) -> None:
+        self._batch_update_card_request_body = BatchUpdateCardRequestBody()
+
+    def uuid(self, uuid: str) -> "BatchUpdateCardRequestBodyBuilder":
+        self._batch_update_card_request_body.uuid = uuid
+        return self
+
+    def sequence(self, sequence: int) -> "BatchUpdateCardRequestBodyBuilder":
+        self._batch_update_card_request_body.sequence = sequence
+        return self
+
+    def actions(self, actions: str) -> "BatchUpdateCardRequestBodyBuilder":
+        self._batch_update_card_request_body.actions = actions
+        return self
+
+    def build(self) -> "BatchUpdateCardRequestBody":
+        return self._batch_update_card_request_body
diff --git a/lark_channel/api/cardkit/v1/model/batch_update_card_response.py b/lark_channel/api/cardkit/v1/model/batch_update_card_response.py
new file mode 100644
index 0000000..50615a8
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/batch_update_card_response.py
@@ -0,0 +1,14 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+
+
+class BatchUpdateCardResponse(BaseResponse):
+    _types = {
+
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+
+        init(self, d, self._types)
diff --git a/lark_channel/api/cardkit/v1/model/card.py b/lark_channel/api/cardkit/v1/model/card.py
new file mode 100644
index 0000000..1dc9bba
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/card.py
@@ -0,0 +1,34 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class Card(object):
+    _types = {
+        "type": str,
+        "data": str,
+    }
+
+    def __init__(self, d=None):
+        self.type: Optional[str] = None
+        self.data: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "CardBuilder":
+        return CardBuilder()
+
+
+class CardBuilder(object):
+    def __init__(self) -> None:
+        self._card = Card()
+
+    def type(self, type: str) -> "CardBuilder":
+        self._card.type = type
+        return self
+
+    def data(self, data: str) -> "CardBuilder":
+        self._card.data = data
+        return self
+
+    def build(self) -> "Card":
+        return self._card
diff --git a/lark_channel/api/cardkit/v1/model/content_card_element_request.py b/lark_channel/api/cardkit/v1/model/content_card_element_request.py
new file mode 100644
index 0000000..ef26695
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/content_card_element_request.py
@@ -0,0 +1,44 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .content_card_element_request_body import ContentCardElementRequestBody
+
+
+class ContentCardElementRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.card_id: Optional[str] = None
+        self.element_id: Optional[str] = None
+        self.request_body: Optional[ContentCardElementRequestBody] = None
+
+    @staticmethod
+    def builder() -> "ContentCardElementRequestBuilder":
+        return ContentCardElementRequestBuilder()
+
+
+class ContentCardElementRequestBuilder(object):
+
+    def __init__(self) -> None:
+        content_card_element_request = ContentCardElementRequest()
+        content_card_element_request.http_method = HttpMethod.PUT
+        content_card_element_request.uri = "/open-apis/cardkit/v1/cards/:card_id/elements/:element_id/content"
+        content_card_element_request.token_types = {AccessTokenType.TENANT}
+        self._content_card_element_request: ContentCardElementRequest = content_card_element_request
+
+    def card_id(self, card_id: str) -> "ContentCardElementRequestBuilder":
+        self._content_card_element_request.card_id = card_id
+        self._content_card_element_request.paths["card_id"] = str(card_id)
+        return self
+
+    def element_id(self, element_id: str) -> "ContentCardElementRequestBuilder":
+        self._content_card_element_request.element_id = element_id
+        self._content_card_element_request.paths["element_id"] = str(element_id)
+        return self
+
+    def request_body(self, request_body: ContentCardElementRequestBody) -> "ContentCardElementRequestBuilder":
+        self._content_card_element_request.request_body = request_body
+        self._content_card_element_request.body = request_body
+        return self
+
+    def build(self) -> ContentCardElementRequest:
+        return self._content_card_element_request
diff --git a/lark_channel/api/cardkit/v1/model/content_card_element_request_body.py b/lark_channel/api/cardkit/v1/model/content_card_element_request_body.py
new file mode 100644
index 0000000..d44cbf3
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/content_card_element_request_body.py
@@ -0,0 +1,40 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class ContentCardElementRequestBody(object):
+    _types = {
+        "uuid": str,
+        "content": str,
+        "sequence": int,
+    }
+
+    def __init__(self, d=None):
+        self.uuid: Optional[str] = None
+        self.content: Optional[str] = None
+        self.sequence: Optional[int] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "ContentCardElementRequestBodyBuilder":
+        return ContentCardElementRequestBodyBuilder()
+
+
+class ContentCardElementRequestBodyBuilder(object):
+    def __init__(self) -> None:
+        self._content_card_element_request_body = ContentCardElementRequestBody()
+
+    def uuid(self, uuid: str) -> "ContentCardElementRequestBodyBuilder":
+        self._content_card_element_request_body.uuid = uuid
+        return self
+
+    def content(self, content: str) -> "ContentCardElementRequestBodyBuilder":
+        self._content_card_element_request_body.content = content
+        return self
+
+    def sequence(self, sequence: int) -> "ContentCardElementRequestBodyBuilder":
+        self._content_card_element_request_body.sequence = sequence
+        return self
+
+    def build(self) -> "ContentCardElementRequestBody":
+        return self._content_card_element_request_body
diff --git a/lark_channel/api/cardkit/v1/model/content_card_element_response.py b/lark_channel/api/cardkit/v1/model/content_card_element_response.py
new file mode 100644
index 0000000..65436c4
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/content_card_element_response.py
@@ -0,0 +1,14 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+
+
+class ContentCardElementResponse(BaseResponse):
+    _types = {
+
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+
+        init(self, d, self._types)
diff --git a/lark_channel/api/cardkit/v1/model/create_card_element_request.py b/lark_channel/api/cardkit/v1/model/create_card_element_request.py
new file mode 100644
index 0000000..320ff2d
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/create_card_element_request.py
@@ -0,0 +1,38 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .create_card_element_request_body import CreateCardElementRequestBody
+
+
+class CreateCardElementRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.card_id: Optional[str] = None
+        self.request_body: Optional[CreateCardElementRequestBody] = None
+
+    @staticmethod
+    def builder() -> "CreateCardElementRequestBuilder":
+        return CreateCardElementRequestBuilder()
+
+
+class CreateCardElementRequestBuilder(object):
+
+    def __init__(self) -> None:
+        create_card_element_request = CreateCardElementRequest()
+        create_card_element_request.http_method = HttpMethod.POST
+        create_card_element_request.uri = "/open-apis/cardkit/v1/cards/:card_id/elements"
+        create_card_element_request.token_types = {AccessTokenType.TENANT}
+        self._create_card_element_request: CreateCardElementRequest = create_card_element_request
+
+    def card_id(self, card_id: str) -> "CreateCardElementRequestBuilder":
+        self._create_card_element_request.card_id = card_id
+        self._create_card_element_request.paths["card_id"] = str(card_id)
+        return self
+
+    def request_body(self, request_body: CreateCardElementRequestBody) -> "CreateCardElementRequestBuilder":
+        self._create_card_element_request.request_body = request_body
+        self._create_card_element_request.body = request_body
+        return self
+
+    def build(self) -> CreateCardElementRequest:
+        return self._create_card_element_request
diff --git a/lark_channel/api/cardkit/v1/model/create_card_element_request_body.py b/lark_channel/api/cardkit/v1/model/create_card_element_request_body.py
new file mode 100644
index 0000000..2f47d1d
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/create_card_element_request_body.py
@@ -0,0 +1,52 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class CreateCardElementRequestBody(object):
+    _types = {
+        "type": str,
+        "target_element_id": str,
+        "uuid": str,
+        "sequence": int,
+        "elements": str,
+    }
+
+    def __init__(self, d=None):
+        self.type: Optional[str] = None
+        self.target_element_id: Optional[str] = None
+        self.uuid: Optional[str] = None
+        self.sequence: Optional[int] = None
+        self.elements: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "CreateCardElementRequestBodyBuilder":
+        return CreateCardElementRequestBodyBuilder()
+
+
+class CreateCardElementRequestBodyBuilder(object):
+    def __init__(self) -> None:
+        self._create_card_element_request_body = CreateCardElementRequestBody()
+
+    def type(self, type: str) -> "CreateCardElementRequestBodyBuilder":
+        self._create_card_element_request_body.type = type
+        return self
+
+    def target_element_id(self, target_element_id: str) -> "CreateCardElementRequestBodyBuilder":
+        self._create_card_element_request_body.target_element_id = target_element_id
+        return self
+
+    def uuid(self, uuid: str) -> "CreateCardElementRequestBodyBuilder":
+        self._create_card_element_request_body.uuid = uuid
+        return self
+
+    def sequence(self, sequence: int) -> "CreateCardElementRequestBodyBuilder":
+        self._create_card_element_request_body.sequence = sequence
+        return self
+
+    def elements(self, elements: str) -> "CreateCardElementRequestBodyBuilder":
+        self._create_card_element_request_body.elements = elements
+        return self
+
+    def build(self) -> "CreateCardElementRequestBody":
+        return self._create_card_element_request_body
diff --git a/lark_channel/api/cardkit/v1/model/create_card_element_response.py b/lark_channel/api/cardkit/v1/model/create_card_element_response.py
new file mode 100644
index 0000000..8ab94f1
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/create_card_element_response.py
@@ -0,0 +1,14 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+
+
+class CreateCardElementResponse(BaseResponse):
+    _types = {
+
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+
+        init(self, d, self._types)
diff --git a/lark_channel/api/cardkit/v1/model/create_card_request.py b/lark_channel/api/cardkit/v1/model/create_card_request.py
new file mode 100644
index 0000000..7145771
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/create_card_request.py
@@ -0,0 +1,32 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .create_card_request_body import CreateCardRequestBody
+
+
+class CreateCardRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.request_body: Optional[CreateCardRequestBody] = None
+
+    @staticmethod
+    def builder() -> "CreateCardRequestBuilder":
+        return CreateCardRequestBuilder()
+
+
+class CreateCardRequestBuilder(object):
+
+    def __init__(self) -> None:
+        create_card_request = CreateCardRequest()
+        create_card_request.http_method = HttpMethod.POST
+        create_card_request.uri = "/open-apis/cardkit/v1/cards"
+        create_card_request.token_types = {AccessTokenType.TENANT}
+        self._create_card_request: CreateCardRequest = create_card_request
+
+    def request_body(self, request_body: CreateCardRequestBody) -> "CreateCardRequestBuilder":
+        self._create_card_request.request_body = request_body
+        self._create_card_request.body = request_body
+        return self
+
+    def build(self) -> CreateCardRequest:
+        return self._create_card_request
diff --git a/lark_channel/api/cardkit/v1/model/create_card_request_body.py b/lark_channel/api/cardkit/v1/model/create_card_request_body.py
new file mode 100644
index 0000000..7765358
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/create_card_request_body.py
@@ -0,0 +1,34 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class CreateCardRequestBody(object):
+    _types = {
+        "type": str,
+        "data": str,
+    }
+
+    def __init__(self, d=None):
+        self.type: Optional[str] = None
+        self.data: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "CreateCardRequestBodyBuilder":
+        return CreateCardRequestBodyBuilder()
+
+
+class CreateCardRequestBodyBuilder(object):
+    def __init__(self) -> None:
+        self._create_card_request_body = CreateCardRequestBody()
+
+    def type(self, type: str) -> "CreateCardRequestBodyBuilder":
+        self._create_card_request_body.type = type
+        return self
+
+    def data(self, data: str) -> "CreateCardRequestBodyBuilder":
+        self._create_card_request_body.data = data
+        return self
+
+    def build(self) -> "CreateCardRequestBody":
+        return self._create_card_request_body
diff --git a/lark_channel/api/cardkit/v1/model/create_card_response.py b/lark_channel/api/cardkit/v1/model/create_card_response.py
new file mode 100644
index 0000000..d973ee8
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/create_card_response.py
@@ -0,0 +1,15 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+from .create_card_response_body import CreateCardResponseBody
+
+
+class CreateCardResponse(BaseResponse):
+    _types = {
+        "data": CreateCardResponseBody
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.data: Optional[CreateCardResponseBody] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/cardkit/v1/model/create_card_response_body.py b/lark_channel/api/cardkit/v1/model/create_card_response_body.py
new file mode 100644
index 0000000..a1edbfb
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/create_card_response_body.py
@@ -0,0 +1,28 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class CreateCardResponseBody(object):
+    _types = {
+        "card_id": str,
+    }
+
+    def __init__(self, d=None):
+        self.card_id: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "CreateCardResponseBodyBuilder":
+        return CreateCardResponseBodyBuilder()
+
+
+class CreateCardResponseBodyBuilder(object):
+    def __init__(self) -> None:
+        self._create_card_response_body = CreateCardResponseBody()
+
+    def card_id(self, card_id: str) -> "CreateCardResponseBodyBuilder":
+        self._create_card_response_body.card_id = card_id
+        return self
+
+    def build(self) -> "CreateCardResponseBody":
+        return self._create_card_response_body
diff --git a/lark_channel/api/cardkit/v1/model/delete_card_element_request.py b/lark_channel/api/cardkit/v1/model/delete_card_element_request.py
new file mode 100644
index 0000000..3a852a1
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/delete_card_element_request.py
@@ -0,0 +1,44 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .delete_card_element_request_body import DeleteCardElementRequestBody
+
+
+class DeleteCardElementRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.card_id: Optional[str] = None
+        self.element_id: Optional[str] = None
+        self.request_body: Optional[DeleteCardElementRequestBody] = None
+
+    @staticmethod
+    def builder() -> "DeleteCardElementRequestBuilder":
+        return DeleteCardElementRequestBuilder()
+
+
+class DeleteCardElementRequestBuilder(object):
+
+    def __init__(self) -> None:
+        delete_card_element_request = DeleteCardElementRequest()
+        delete_card_element_request.http_method = HttpMethod.DELETE
+        delete_card_element_request.uri = "/open-apis/cardkit/v1/cards/:card_id/elements/:element_id"
+        delete_card_element_request.token_types = {AccessTokenType.TENANT}
+        self._delete_card_element_request: DeleteCardElementRequest = delete_card_element_request
+
+    def card_id(self, card_id: str) -> "DeleteCardElementRequestBuilder":
+        self._delete_card_element_request.card_id = card_id
+        self._delete_card_element_request.paths["card_id"] = str(card_id)
+        return self
+
+    def element_id(self, element_id: str) -> "DeleteCardElementRequestBuilder":
+        self._delete_card_element_request.element_id = element_id
+        self._delete_card_element_request.paths["element_id"] = str(element_id)
+        return self
+
+    def request_body(self, request_body: DeleteCardElementRequestBody) -> "DeleteCardElementRequestBuilder":
+        self._delete_card_element_request.request_body = request_body
+        self._delete_card_element_request.body = request_body
+        return self
+
+    def build(self) -> DeleteCardElementRequest:
+        return self._delete_card_element_request
diff --git a/lark_channel/api/cardkit/v1/model/delete_card_element_request_body.py b/lark_channel/api/cardkit/v1/model/delete_card_element_request_body.py
new file mode 100644
index 0000000..d361bc5
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/delete_card_element_request_body.py
@@ -0,0 +1,34 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class DeleteCardElementRequestBody(object):
+    _types = {
+        "uuid": str,
+        "sequence": int,
+    }
+
+    def __init__(self, d=None):
+        self.uuid: Optional[str] = None
+        self.sequence: Optional[int] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "DeleteCardElementRequestBodyBuilder":
+        return DeleteCardElementRequestBodyBuilder()
+
+
+class DeleteCardElementRequestBodyBuilder(object):
+    def __init__(self) -> None:
+        self._delete_card_element_request_body = DeleteCardElementRequestBody()
+
+    def uuid(self, uuid: str) -> "DeleteCardElementRequestBodyBuilder":
+        self._delete_card_element_request_body.uuid = uuid
+        return self
+
+    def sequence(self, sequence: int) -> "DeleteCardElementRequestBodyBuilder":
+        self._delete_card_element_request_body.sequence = sequence
+        return self
+
+    def build(self) -> "DeleteCardElementRequestBody":
+        return self._delete_card_element_request_body
diff --git a/lark_channel/api/cardkit/v1/model/delete_card_element_response.py b/lark_channel/api/cardkit/v1/model/delete_card_element_response.py
new file mode 100644
index 0000000..664484a
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/delete_card_element_response.py
@@ -0,0 +1,14 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+
+
+class DeleteCardElementResponse(BaseResponse):
+    _types = {
+
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+
+        init(self, d, self._types)
diff --git a/lark_channel/api/cardkit/v1/model/id_convert_card_request.py b/lark_channel/api/cardkit/v1/model/id_convert_card_request.py
new file mode 100644
index 0000000..9f737f7
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/id_convert_card_request.py
@@ -0,0 +1,32 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .id_convert_card_request_body import IdConvertCardRequestBody
+
+
+class IdConvertCardRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.request_body: Optional[IdConvertCardRequestBody] = None
+
+    @staticmethod
+    def builder() -> "IdConvertCardRequestBuilder":
+        return IdConvertCardRequestBuilder()
+
+
+class IdConvertCardRequestBuilder(object):
+
+    def __init__(self) -> None:
+        id_convert_card_request = IdConvertCardRequest()
+        id_convert_card_request.http_method = HttpMethod.POST
+        id_convert_card_request.uri = "/open-apis/cardkit/v1/cards/id_convert"
+        id_convert_card_request.token_types = {AccessTokenType.TENANT}
+        self._id_convert_card_request: IdConvertCardRequest = id_convert_card_request
+
+    def request_body(self, request_body: IdConvertCardRequestBody) -> "IdConvertCardRequestBuilder":
+        self._id_convert_card_request.request_body = request_body
+        self._id_convert_card_request.body = request_body
+        return self
+
+    def build(self) -> IdConvertCardRequest:
+        return self._id_convert_card_request
diff --git a/lark_channel/api/cardkit/v1/model/id_convert_card_request_body.py b/lark_channel/api/cardkit/v1/model/id_convert_card_request_body.py
new file mode 100644
index 0000000..ce6fca3
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/id_convert_card_request_body.py
@@ -0,0 +1,28 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class IdConvertCardRequestBody(object):
+    _types = {
+        "message_id": str,
+    }
+
+    def __init__(self, d=None):
+        self.message_id: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "IdConvertCardRequestBodyBuilder":
+        return IdConvertCardRequestBodyBuilder()
+
+
+class IdConvertCardRequestBodyBuilder(object):
+    def __init__(self) -> None:
+        self._id_convert_card_request_body = IdConvertCardRequestBody()
+
+    def message_id(self, message_id: str) -> "IdConvertCardRequestBodyBuilder":
+        self._id_convert_card_request_body.message_id = message_id
+        return self
+
+    def build(self) -> "IdConvertCardRequestBody":
+        return self._id_convert_card_request_body
diff --git a/lark_channel/api/cardkit/v1/model/id_convert_card_response.py b/lark_channel/api/cardkit/v1/model/id_convert_card_response.py
new file mode 100644
index 0000000..6dc05b2
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/id_convert_card_response.py
@@ -0,0 +1,15 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+from .id_convert_card_response_body import IdConvertCardResponseBody
+
+
+class IdConvertCardResponse(BaseResponse):
+    _types = {
+        "data": IdConvertCardResponseBody
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.data: Optional[IdConvertCardResponseBody] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/cardkit/v1/model/id_convert_card_response_body.py b/lark_channel/api/cardkit/v1/model/id_convert_card_response_body.py
new file mode 100644
index 0000000..adc56bd
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/id_convert_card_response_body.py
@@ -0,0 +1,28 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class IdConvertCardResponseBody(object):
+    _types = {
+        "card_id": str,
+    }
+
+    def __init__(self, d=None):
+        self.card_id: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "IdConvertCardResponseBodyBuilder":
+        return IdConvertCardResponseBodyBuilder()
+
+
+class IdConvertCardResponseBodyBuilder(object):
+    def __init__(self) -> None:
+        self._id_convert_card_response_body = IdConvertCardResponseBody()
+
+    def card_id(self, card_id: str) -> "IdConvertCardResponseBodyBuilder":
+        self._id_convert_card_response_body.card_id = card_id
+        return self
+
+    def build(self) -> "IdConvertCardResponseBody":
+        return self._id_convert_card_response_body
diff --git a/lark_channel/api/cardkit/v1/model/patch_card_element_request.py b/lark_channel/api/cardkit/v1/model/patch_card_element_request.py
new file mode 100644
index 0000000..751cf95
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/patch_card_element_request.py
@@ -0,0 +1,44 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .patch_card_element_request_body import PatchCardElementRequestBody
+
+
+class PatchCardElementRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.card_id: Optional[str] = None
+        self.element_id: Optional[str] = None
+        self.request_body: Optional[PatchCardElementRequestBody] = None
+
+    @staticmethod
+    def builder() -> "PatchCardElementRequestBuilder":
+        return PatchCardElementRequestBuilder()
+
+
+class PatchCardElementRequestBuilder(object):
+
+    def __init__(self) -> None:
+        patch_card_element_request = PatchCardElementRequest()
+        patch_card_element_request.http_method = HttpMethod.PATCH
+        patch_card_element_request.uri = "/open-apis/cardkit/v1/cards/:card_id/elements/:element_id"
+        patch_card_element_request.token_types = {AccessTokenType.TENANT}
+        self._patch_card_element_request: PatchCardElementRequest = patch_card_element_request
+
+    def card_id(self, card_id: str) -> "PatchCardElementRequestBuilder":
+        self._patch_card_element_request.card_id = card_id
+        self._patch_card_element_request.paths["card_id"] = str(card_id)
+        return self
+
+    def element_id(self, element_id: str) -> "PatchCardElementRequestBuilder":
+        self._patch_card_element_request.element_id = element_id
+        self._patch_card_element_request.paths["element_id"] = str(element_id)
+        return self
+
+    def request_body(self, request_body: PatchCardElementRequestBody) -> "PatchCardElementRequestBuilder":
+        self._patch_card_element_request.request_body = request_body
+        self._patch_card_element_request.body = request_body
+        return self
+
+    def build(self) -> PatchCardElementRequest:
+        return self._patch_card_element_request
diff --git a/lark_channel/api/cardkit/v1/model/patch_card_element_request_body.py b/lark_channel/api/cardkit/v1/model/patch_card_element_request_body.py
new file mode 100644
index 0000000..3534ba0
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/patch_card_element_request_body.py
@@ -0,0 +1,40 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class PatchCardElementRequestBody(object):
+    _types = {
+        "partial_element": str,
+        "uuid": str,
+        "sequence": int,
+    }
+
+    def __init__(self, d=None):
+        self.partial_element: Optional[str] = None
+        self.uuid: Optional[str] = None
+        self.sequence: Optional[int] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "PatchCardElementRequestBodyBuilder":
+        return PatchCardElementRequestBodyBuilder()
+
+
+class PatchCardElementRequestBodyBuilder(object):
+    def __init__(self) -> None:
+        self._patch_card_element_request_body = PatchCardElementRequestBody()
+
+    def partial_element(self, partial_element: str) -> "PatchCardElementRequestBodyBuilder":
+        self._patch_card_element_request_body.partial_element = partial_element
+        return self
+
+    def uuid(self, uuid: str) -> "PatchCardElementRequestBodyBuilder":
+        self._patch_card_element_request_body.uuid = uuid
+        return self
+
+    def sequence(self, sequence: int) -> "PatchCardElementRequestBodyBuilder":
+        self._patch_card_element_request_body.sequence = sequence
+        return self
+
+    def build(self) -> "PatchCardElementRequestBody":
+        return self._patch_card_element_request_body
diff --git a/lark_channel/api/cardkit/v1/model/patch_card_element_response.py b/lark_channel/api/cardkit/v1/model/patch_card_element_response.py
new file mode 100644
index 0000000..9807955
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/patch_card_element_response.py
@@ -0,0 +1,14 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+
+
+class PatchCardElementResponse(BaseResponse):
+    _types = {
+
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+
+        init(self, d, self._types)
diff --git a/lark_channel/api/cardkit/v1/model/settings_card_request.py b/lark_channel/api/cardkit/v1/model/settings_card_request.py
new file mode 100644
index 0000000..3bff4b5
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/settings_card_request.py
@@ -0,0 +1,38 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .settings_card_request_body import SettingsCardRequestBody
+
+
+class SettingsCardRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.card_id: Optional[str] = None
+        self.request_body: Optional[SettingsCardRequestBody] = None
+
+    @staticmethod
+    def builder() -> "SettingsCardRequestBuilder":
+        return SettingsCardRequestBuilder()
+
+
+class SettingsCardRequestBuilder(object):
+
+    def __init__(self) -> None:
+        settings_card_request = SettingsCardRequest()
+        settings_card_request.http_method = HttpMethod.PATCH
+        settings_card_request.uri = "/open-apis/cardkit/v1/cards/:card_id/settings"
+        settings_card_request.token_types = {AccessTokenType.TENANT}
+        self._settings_card_request: SettingsCardRequest = settings_card_request
+
+    def card_id(self, card_id: str) -> "SettingsCardRequestBuilder":
+        self._settings_card_request.card_id = card_id
+        self._settings_card_request.paths["card_id"] = str(card_id)
+        return self
+
+    def request_body(self, request_body: SettingsCardRequestBody) -> "SettingsCardRequestBuilder":
+        self._settings_card_request.request_body = request_body
+        self._settings_card_request.body = request_body
+        return self
+
+    def build(self) -> SettingsCardRequest:
+        return self._settings_card_request
diff --git a/lark_channel/api/cardkit/v1/model/settings_card_request_body.py b/lark_channel/api/cardkit/v1/model/settings_card_request_body.py
new file mode 100644
index 0000000..e184aed
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/settings_card_request_body.py
@@ -0,0 +1,40 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class SettingsCardRequestBody(object):
+    _types = {
+        "settings": str,
+        "uuid": str,
+        "sequence": int,
+    }
+
+    def __init__(self, d=None):
+        self.settings: Optional[str] = None
+        self.uuid: Optional[str] = None
+        self.sequence: Optional[int] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "SettingsCardRequestBodyBuilder":
+        return SettingsCardRequestBodyBuilder()
+
+
+class SettingsCardRequestBodyBuilder(object):
+    def __init__(self) -> None:
+        self._settings_card_request_body = SettingsCardRequestBody()
+
+    def settings(self, settings: str) -> "SettingsCardRequestBodyBuilder":
+        self._settings_card_request_body.settings = settings
+        return self
+
+    def uuid(self, uuid: str) -> "SettingsCardRequestBodyBuilder":
+        self._settings_card_request_body.uuid = uuid
+        return self
+
+    def sequence(self, sequence: int) -> "SettingsCardRequestBodyBuilder":
+        self._settings_card_request_body.sequence = sequence
+        return self
+
+    def build(self) -> "SettingsCardRequestBody":
+        return self._settings_card_request_body
diff --git a/lark_channel/api/cardkit/v1/model/settings_card_response.py b/lark_channel/api/cardkit/v1/model/settings_card_response.py
new file mode 100644
index 0000000..cc63a68
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/settings_card_response.py
@@ -0,0 +1,14 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+
+
+class SettingsCardResponse(BaseResponse):
+    _types = {
+
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+
+        init(self, d, self._types)
diff --git a/lark_channel/api/cardkit/v1/model/update_card_element_request.py b/lark_channel/api/cardkit/v1/model/update_card_element_request.py
new file mode 100644
index 0000000..82dfa9e
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/update_card_element_request.py
@@ -0,0 +1,44 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .update_card_element_request_body import UpdateCardElementRequestBody
+
+
+class UpdateCardElementRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.card_id: Optional[str] = None
+        self.element_id: Optional[str] = None
+        self.request_body: Optional[UpdateCardElementRequestBody] = None
+
+    @staticmethod
+    def builder() -> "UpdateCardElementRequestBuilder":
+        return UpdateCardElementRequestBuilder()
+
+
+class UpdateCardElementRequestBuilder(object):
+
+    def __init__(self) -> None:
+        update_card_element_request = UpdateCardElementRequest()
+        update_card_element_request.http_method = HttpMethod.PUT
+        update_card_element_request.uri = "/open-apis/cardkit/v1/cards/:card_id/elements/:element_id"
+        update_card_element_request.token_types = {AccessTokenType.TENANT}
+        self._update_card_element_request: UpdateCardElementRequest = update_card_element_request
+
+    def card_id(self, card_id: str) -> "UpdateCardElementRequestBuilder":
+        self._update_card_element_request.card_id = card_id
+        self._update_card_element_request.paths["card_id"] = str(card_id)
+        return self
+
+    def element_id(self, element_id: str) -> "UpdateCardElementRequestBuilder":
+        self._update_card_element_request.element_id = element_id
+        self._update_card_element_request.paths["element_id"] = str(element_id)
+        return self
+
+    def request_body(self, request_body: UpdateCardElementRequestBody) -> "UpdateCardElementRequestBuilder":
+        self._update_card_element_request.request_body = request_body
+        self._update_card_element_request.body = request_body
+        return self
+
+    def build(self) -> UpdateCardElementRequest:
+        return self._update_card_element_request
diff --git a/lark_channel/api/cardkit/v1/model/update_card_element_request_body.py b/lark_channel/api/cardkit/v1/model/update_card_element_request_body.py
new file mode 100644
index 0000000..2d4ae30
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/update_card_element_request_body.py
@@ -0,0 +1,40 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class UpdateCardElementRequestBody(object):
+    _types = {
+        "uuid": str,
+        "element": str,
+        "sequence": int,
+    }
+
+    def __init__(self, d=None):
+        self.uuid: Optional[str] = None
+        self.element: Optional[str] = None
+        self.sequence: Optional[int] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "UpdateCardElementRequestBodyBuilder":
+        return UpdateCardElementRequestBodyBuilder()
+
+
+class UpdateCardElementRequestBodyBuilder(object):
+    def __init__(self) -> None:
+        self._update_card_element_request_body = UpdateCardElementRequestBody()
+
+    def uuid(self, uuid: str) -> "UpdateCardElementRequestBodyBuilder":
+        self._update_card_element_request_body.uuid = uuid
+        return self
+
+    def element(self, element: str) -> "UpdateCardElementRequestBodyBuilder":
+        self._update_card_element_request_body.element = element
+        return self
+
+    def sequence(self, sequence: int) -> "UpdateCardElementRequestBodyBuilder":
+        self._update_card_element_request_body.sequence = sequence
+        return self
+
+    def build(self) -> "UpdateCardElementRequestBody":
+        return self._update_card_element_request_body
diff --git a/lark_channel/api/cardkit/v1/model/update_card_element_response.py b/lark_channel/api/cardkit/v1/model/update_card_element_response.py
new file mode 100644
index 0000000..6984da5
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/update_card_element_response.py
@@ -0,0 +1,14 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+
+
+class UpdateCardElementResponse(BaseResponse):
+    _types = {
+
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+
+        init(self, d, self._types)
diff --git a/lark_channel/api/cardkit/v1/model/update_card_request.py b/lark_channel/api/cardkit/v1/model/update_card_request.py
new file mode 100644
index 0000000..79a7f4a
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/update_card_request.py
@@ -0,0 +1,38 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .update_card_request_body import UpdateCardRequestBody
+
+
+class UpdateCardRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.card_id: Optional[str] = None
+        self.request_body: Optional[UpdateCardRequestBody] = None
+
+    @staticmethod
+    def builder() -> "UpdateCardRequestBuilder":
+        return UpdateCardRequestBuilder()
+
+
+class UpdateCardRequestBuilder(object):
+
+    def __init__(self) -> None:
+        update_card_request = UpdateCardRequest()
+        update_card_request.http_method = HttpMethod.PUT
+        update_card_request.uri = "/open-apis/cardkit/v1/cards/:card_id"
+        update_card_request.token_types = {AccessTokenType.TENANT}
+        self._update_card_request: UpdateCardRequest = update_card_request
+
+    def card_id(self, card_id: str) -> "UpdateCardRequestBuilder":
+        self._update_card_request.card_id = card_id
+        self._update_card_request.paths["card_id"] = str(card_id)
+        return self
+
+    def request_body(self, request_body: UpdateCardRequestBody) -> "UpdateCardRequestBuilder":
+        self._update_card_request.request_body = request_body
+        self._update_card_request.body = request_body
+        return self
+
+    def build(self) -> UpdateCardRequest:
+        return self._update_card_request
diff --git a/lark_channel/api/cardkit/v1/model/update_card_request_body.py b/lark_channel/api/cardkit/v1/model/update_card_request_body.py
new file mode 100644
index 0000000..d604b24
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/update_card_request_body.py
@@ -0,0 +1,41 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .card import Card
+
+
+class UpdateCardRequestBody(object):
+    _types = {
+        "card": Card,
+        "uuid": str,
+        "sequence": int,
+    }
+
+    def __init__(self, d=None):
+        self.card: Optional[Card] = None
+        self.uuid: Optional[str] = None
+        self.sequence: Optional[int] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "UpdateCardRequestBodyBuilder":
+        return UpdateCardRequestBodyBuilder()
+
+
+class UpdateCardRequestBodyBuilder(object):
+    def __init__(self) -> None:
+        self._update_card_request_body = UpdateCardRequestBody()
+
+    def card(self, card: Card) -> "UpdateCardRequestBodyBuilder":
+        self._update_card_request_body.card = card
+        return self
+
+    def uuid(self, uuid: str) -> "UpdateCardRequestBodyBuilder":
+        self._update_card_request_body.uuid = uuid
+        return self
+
+    def sequence(self, sequence: int) -> "UpdateCardRequestBodyBuilder":
+        self._update_card_request_body.sequence = sequence
+        return self
+
+    def build(self) -> "UpdateCardRequestBody":
+        return self._update_card_request_body
diff --git a/lark_channel/api/cardkit/v1/model/update_card_response.py b/lark_channel/api/cardkit/v1/model/update_card_response.py
new file mode 100644
index 0000000..75873c2
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/model/update_card_response.py
@@ -0,0 +1,14 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+
+
+class UpdateCardResponse(BaseResponse):
+    _types = {
+
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+
+        init(self, d, self._types)
diff --git a/lark_channel/api/cardkit/v1/resource/__init__.py b/lark_channel/api/cardkit/v1/resource/__init__.py
new file mode 100644
index 0000000..87e5c69
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/resource/__init__.py
@@ -0,0 +1,4 @@
+from .card import Card
+from .card_element import CardElement
+
+__all__ = ["Card", "CardElement"]
diff --git a/lark_channel/api/cardkit/v1/resource/card.py b/lark_channel/api/cardkit/v1/resource/card.py
new file mode 100644
index 0000000..28356ce
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/resource/card.py
@@ -0,0 +1,209 @@
+import io
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.const import UTF_8, CONTENT_TYPE, APPLICATION_JSON
+from lark_channel.core import JSON
+from lark_channel.core.token import verify
+from lark_channel.core.http import Transport
+from lark_channel.core.model import Config, RequestOption, RawResponse
+from lark_channel.core.utils import Files
+from requests_toolbelt import MultipartEncoder
+from ..model.batch_update_card_request import BatchUpdateCardRequest
+from ..model.batch_update_card_response import BatchUpdateCardResponse
+from ..model.create_card_request import CreateCardRequest
+from ..model.create_card_response import CreateCardResponse
+from ..model.id_convert_card_request import IdConvertCardRequest
+from ..model.id_convert_card_response import IdConvertCardResponse
+from ..model.settings_card_request import SettingsCardRequest
+from ..model.settings_card_response import SettingsCardResponse
+from ..model.update_card_request import UpdateCardRequest
+from ..model.update_card_response import UpdateCardResponse
+
+
+class Card(object):
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+
+    def batch_update(self, request: BatchUpdateCardRequest,
+                     option: Optional[RequestOption] = None) -> BatchUpdateCardResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: BatchUpdateCardResponse = JSON.unmarshal(str(resp.content, UTF_8), BatchUpdateCardResponse)
+        response.raw = resp
+
+        return response
+
+    async def abatch_update(self, request: BatchUpdateCardRequest,
+                            option: Optional[RequestOption] = None) -> BatchUpdateCardResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: BatchUpdateCardResponse = JSON.unmarshal(str(resp.content, UTF_8), BatchUpdateCardResponse)
+        response.raw = resp
+
+        return response
+
+    def create(self, request: CreateCardRequest, option: Optional[RequestOption] = None) -> CreateCardResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: CreateCardResponse = JSON.unmarshal(str(resp.content, UTF_8), CreateCardResponse)
+        response.raw = resp
+
+        return response
+
+    async def acreate(self, request: CreateCardRequest, option: Optional[RequestOption] = None) -> CreateCardResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: CreateCardResponse = JSON.unmarshal(str(resp.content, UTF_8), CreateCardResponse)
+        response.raw = resp
+
+        return response
+
+    def id_convert(self, request: IdConvertCardRequest,
+                   option: Optional[RequestOption] = None) -> IdConvertCardResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: IdConvertCardResponse = JSON.unmarshal(str(resp.content, UTF_8), IdConvertCardResponse)
+        response.raw = resp
+
+        return response
+
+    async def aid_convert(self, request: IdConvertCardRequest,
+                          option: Optional[RequestOption] = None) -> IdConvertCardResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: IdConvertCardResponse = JSON.unmarshal(str(resp.content, UTF_8), IdConvertCardResponse)
+        response.raw = resp
+
+        return response
+
+    def settings(self, request: SettingsCardRequest, option: Optional[RequestOption] = None) -> SettingsCardResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: SettingsCardResponse = JSON.unmarshal(str(resp.content, UTF_8), SettingsCardResponse)
+        response.raw = resp
+
+        return response
+
+    async def asettings(self, request: SettingsCardRequest,
+                        option: Optional[RequestOption] = None) -> SettingsCardResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: SettingsCardResponse = JSON.unmarshal(str(resp.content, UTF_8), SettingsCardResponse)
+        response.raw = resp
+
+        return response
+
+    def update(self, request: UpdateCardRequest, option: Optional[RequestOption] = None) -> UpdateCardResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: UpdateCardResponse = JSON.unmarshal(str(resp.content, UTF_8), UpdateCardResponse)
+        response.raw = resp
+
+        return response
+
+    async def aupdate(self, request: UpdateCardRequest, option: Optional[RequestOption] = None) -> UpdateCardResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: UpdateCardResponse = JSON.unmarshal(str(resp.content, UTF_8), UpdateCardResponse)
+        response.raw = resp
+
+        return response
diff --git a/lark_channel/api/cardkit/v1/resource/card_element.py b/lark_channel/api/cardkit/v1/resource/card_element.py
new file mode 100644
index 0000000..712e881
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/resource/card_element.py
@@ -0,0 +1,214 @@
+import io
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.const import UTF_8, CONTENT_TYPE, APPLICATION_JSON
+from lark_channel.core import JSON
+from lark_channel.core.token import verify
+from lark_channel.core.http import Transport
+from lark_channel.core.model import Config, RequestOption, RawResponse
+from lark_channel.core.utils import Files
+from requests_toolbelt import MultipartEncoder
+from ..model.content_card_element_request import ContentCardElementRequest
+from ..model.content_card_element_response import ContentCardElementResponse
+from ..model.create_card_element_request import CreateCardElementRequest
+from ..model.create_card_element_response import CreateCardElementResponse
+from ..model.delete_card_element_request import DeleteCardElementRequest
+from ..model.delete_card_element_response import DeleteCardElementResponse
+from ..model.patch_card_element_request import PatchCardElementRequest
+from ..model.patch_card_element_response import PatchCardElementResponse
+from ..model.update_card_element_request import UpdateCardElementRequest
+from ..model.update_card_element_response import UpdateCardElementResponse
+
+
+class CardElement(object):
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+
+    def content(self, request: ContentCardElementRequest,
+                option: Optional[RequestOption] = None) -> ContentCardElementResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: ContentCardElementResponse = JSON.unmarshal(str(resp.content, UTF_8), ContentCardElementResponse)
+        response.raw = resp
+
+        return response
+
+    async def acontent(self, request: ContentCardElementRequest,
+                       option: Optional[RequestOption] = None) -> ContentCardElementResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: ContentCardElementResponse = JSON.unmarshal(str(resp.content, UTF_8), ContentCardElementResponse)
+        response.raw = resp
+
+        return response
+
+    def create(self, request: CreateCardElementRequest,
+               option: Optional[RequestOption] = None) -> CreateCardElementResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: CreateCardElementResponse = JSON.unmarshal(str(resp.content, UTF_8), CreateCardElementResponse)
+        response.raw = resp
+
+        return response
+
+    async def acreate(self, request: CreateCardElementRequest,
+                      option: Optional[RequestOption] = None) -> CreateCardElementResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: CreateCardElementResponse = JSON.unmarshal(str(resp.content, UTF_8), CreateCardElementResponse)
+        response.raw = resp
+
+        return response
+
+    def delete(self, request: DeleteCardElementRequest,
+               option: Optional[RequestOption] = None) -> DeleteCardElementResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: DeleteCardElementResponse = JSON.unmarshal(str(resp.content, UTF_8), DeleteCardElementResponse)
+        response.raw = resp
+
+        return response
+
+    async def adelete(self, request: DeleteCardElementRequest,
+                      option: Optional[RequestOption] = None) -> DeleteCardElementResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: DeleteCardElementResponse = JSON.unmarshal(str(resp.content, UTF_8), DeleteCardElementResponse)
+        response.raw = resp
+
+        return response
+
+    def patch(self, request: PatchCardElementRequest,
+              option: Optional[RequestOption] = None) -> PatchCardElementResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: PatchCardElementResponse = JSON.unmarshal(str(resp.content, UTF_8), PatchCardElementResponse)
+        response.raw = resp
+
+        return response
+
+    async def apatch(self, request: PatchCardElementRequest,
+                     option: Optional[RequestOption] = None) -> PatchCardElementResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: PatchCardElementResponse = JSON.unmarshal(str(resp.content, UTF_8), PatchCardElementResponse)
+        response.raw = resp
+
+        return response
+
+    def update(self, request: UpdateCardElementRequest,
+               option: Optional[RequestOption] = None) -> UpdateCardElementResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: UpdateCardElementResponse = JSON.unmarshal(str(resp.content, UTF_8), UpdateCardElementResponse)
+        response.raw = resp
+
+        return response
+
+    async def aupdate(self, request: UpdateCardElementRequest,
+                      option: Optional[RequestOption] = None) -> UpdateCardElementResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: UpdateCardElementResponse = JSON.unmarshal(str(resp.content, UTF_8), UpdateCardElementResponse)
+        response.raw = resp
+
+        return response
diff --git a/lark_channel/api/cardkit/v1/version.py b/lark_channel/api/cardkit/v1/version.py
new file mode 100644
index 0000000..c2b8066
--- /dev/null
+++ b/lark_channel/api/cardkit/v1/version.py
@@ -0,0 +1,9 @@
+from lark_channel.core.model import Config
+
+from .resource import Card, CardElement
+
+
+class V1(object):
+    def __init__(self, config: Config) -> None:
+        self.card: Card = Card(config)
+        self.card_element: CardElement = CardElement(config)
diff --git a/lark_channel/api/contact/__init__.py b/lark_channel/api/contact/__init__.py
new file mode 100644
index 0000000..a10884f
--- /dev/null
+++ b/lark_channel/api/contact/__init__.py
@@ -0,0 +1 @@
+from . import v3
diff --git a/lark_channel/api/contact/service.py b/lark_channel/api/contact/service.py
new file mode 100644
index 0000000..fe1603c
--- /dev/null
+++ b/lark_channel/api/contact/service.py
@@ -0,0 +1,7 @@
+from lark_channel.core.model import Config
+from .v3.version import V3
+
+
+class ContactService(object):
+    def __init__(self, config: Config) -> None:
+        self.v3: V3 = V3(config)
diff --git a/lark_channel/api/contact/v3/__init__.py b/lark_channel/api/contact/v3/__init__.py
new file mode 100644
index 0000000..faf4f40
--- /dev/null
+++ b/lark_channel/api/contact/v3/__init__.py
@@ -0,0 +1,5 @@
+"""Minimal Contact v3 resources required by lark_channel."""
+
+from .version import V3
+
+__all__ = ["V3"]
diff --git a/lark_channel/api/contact/v3/model/__init__.py b/lark_channel/api/contact/v3/model/__init__.py
new file mode 100644
index 0000000..d8d811c
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/__init__.py
@@ -0,0 +1 @@
+"""Contact model submodules are imported explicitly by lark_channel."""
diff --git a/lark_channel/api/contact/v3/model/avatar_info.py b/lark_channel/api/contact/v3/model/avatar_info.py
new file mode 100644
index 0000000..5f22d9c
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/avatar_info.py
@@ -0,0 +1,46 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class AvatarInfo(object):
+    _types = {
+        "avatar_72": str,
+        "avatar_240": str,
+        "avatar_640": str,
+        "avatar_origin": str,
+    }
+
+    def __init__(self, d=None):
+        self.avatar_72: Optional[str] = None
+        self.avatar_240: Optional[str] = None
+        self.avatar_640: Optional[str] = None
+        self.avatar_origin: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "AvatarInfoBuilder":
+        return AvatarInfoBuilder()
+
+
+class AvatarInfoBuilder(object):
+    def __init__(self) -> None:
+        self._avatar_info = AvatarInfo()
+
+    def avatar_72(self, avatar_72: str) -> "AvatarInfoBuilder":
+        self._avatar_info.avatar_72 = avatar_72
+        return self
+
+    def avatar_240(self, avatar_240: str) -> "AvatarInfoBuilder":
+        self._avatar_info.avatar_240 = avatar_240
+        return self
+
+    def avatar_640(self, avatar_640: str) -> "AvatarInfoBuilder":
+        self._avatar_info.avatar_640 = avatar_640
+        return self
+
+    def avatar_origin(self, avatar_origin: str) -> "AvatarInfoBuilder":
+        self._avatar_info.avatar_origin = avatar_origin
+        return self
+
+    def build(self) -> "AvatarInfo":
+        return self._avatar_info
diff --git a/lark_channel/api/contact/v3/model/batch_get_id_user_request.py b/lark_channel/api/contact/v3/model/batch_get_id_user_request.py
new file mode 100644
index 0000000..ec976f1
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/batch_get_id_user_request.py
@@ -0,0 +1,38 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .batch_get_id_user_request_body import BatchGetIdUserRequestBody
+
+
+class BatchGetIdUserRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.user_id_type: Optional[str] = None
+        self.request_body: Optional[BatchGetIdUserRequestBody] = None
+
+    @staticmethod
+    def builder() -> "BatchGetIdUserRequestBuilder":
+        return BatchGetIdUserRequestBuilder()
+
+
+class BatchGetIdUserRequestBuilder(object):
+
+    def __init__(self) -> None:
+        batch_get_id_user_request = BatchGetIdUserRequest()
+        batch_get_id_user_request.http_method = HttpMethod.POST
+        batch_get_id_user_request.uri = "/open-apis/contact/v3/users/batch_get_id"
+        batch_get_id_user_request.token_types = {AccessTokenType.TENANT}
+        self._batch_get_id_user_request: BatchGetIdUserRequest = batch_get_id_user_request
+
+    def user_id_type(self, user_id_type: str) -> "BatchGetIdUserRequestBuilder":
+        self._batch_get_id_user_request.user_id_type = user_id_type
+        self._batch_get_id_user_request.add_query("user_id_type", user_id_type)
+        return self
+
+    def request_body(self, request_body: BatchGetIdUserRequestBody) -> "BatchGetIdUserRequestBuilder":
+        self._batch_get_id_user_request.request_body = request_body
+        self._batch_get_id_user_request.body = request_body
+        return self
+
+    def build(self) -> BatchGetIdUserRequest:
+        return self._batch_get_id_user_request
diff --git a/lark_channel/api/contact/v3/model/batch_get_id_user_request_body.py b/lark_channel/api/contact/v3/model/batch_get_id_user_request_body.py
new file mode 100644
index 0000000..3d972f8
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/batch_get_id_user_request_body.py
@@ -0,0 +1,40 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class BatchGetIdUserRequestBody(object):
+    _types = {
+        "emails": List[str],
+        "mobiles": List[str],
+        "include_resigned": bool,
+    }
+
+    def __init__(self, d=None):
+        self.emails: Optional[List[str]] = None
+        self.mobiles: Optional[List[str]] = None
+        self.include_resigned: Optional[bool] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "BatchGetIdUserRequestBodyBuilder":
+        return BatchGetIdUserRequestBodyBuilder()
+
+
+class BatchGetIdUserRequestBodyBuilder(object):
+    def __init__(self) -> None:
+        self._batch_get_id_user_request_body = BatchGetIdUserRequestBody()
+
+    def emails(self, emails: List[str]) -> "BatchGetIdUserRequestBodyBuilder":
+        self._batch_get_id_user_request_body.emails = emails
+        return self
+
+    def mobiles(self, mobiles: List[str]) -> "BatchGetIdUserRequestBodyBuilder":
+        self._batch_get_id_user_request_body.mobiles = mobiles
+        return self
+
+    def include_resigned(self, include_resigned: bool) -> "BatchGetIdUserRequestBodyBuilder":
+        self._batch_get_id_user_request_body.include_resigned = include_resigned
+        return self
+
+    def build(self) -> "BatchGetIdUserRequestBody":
+        return self._batch_get_id_user_request_body
diff --git a/lark_channel/api/contact/v3/model/batch_get_id_user_response.py b/lark_channel/api/contact/v3/model/batch_get_id_user_response.py
new file mode 100644
index 0000000..63a850d
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/batch_get_id_user_response.py
@@ -0,0 +1,15 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+from .batch_get_id_user_response_body import BatchGetIdUserResponseBody
+
+
+class BatchGetIdUserResponse(BaseResponse):
+    _types = {
+        "data": BatchGetIdUserResponseBody
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.data: Optional[BatchGetIdUserResponseBody] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/contact/v3/model/batch_get_id_user_response_body.py b/lark_channel/api/contact/v3/model/batch_get_id_user_response_body.py
new file mode 100644
index 0000000..7aec0f2
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/batch_get_id_user_response_body.py
@@ -0,0 +1,29 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .user_contact_info import UserContactInfo
+
+
+class BatchGetIdUserResponseBody(object):
+    _types = {
+        "user_list": List[UserContactInfo],
+    }
+
+    def __init__(self, d=None):
+        self.user_list: Optional[List[UserContactInfo]] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "BatchGetIdUserResponseBodyBuilder":
+        return BatchGetIdUserResponseBodyBuilder()
+
+
+class BatchGetIdUserResponseBodyBuilder(object):
+    def __init__(self) -> None:
+        self._batch_get_id_user_response_body = BatchGetIdUserResponseBody()
+
+    def user_list(self, user_list: List[UserContactInfo]) -> "BatchGetIdUserResponseBodyBuilder":
+        self._batch_get_id_user_response_body.user_list = user_list
+        return self
+
+    def build(self) -> "BatchGetIdUserResponseBody":
+        return self._batch_get_id_user_response_body
diff --git a/lark_channel/api/contact/v3/model/batch_user_request.py b/lark_channel/api/contact/v3/model/batch_user_request.py
new file mode 100644
index 0000000..67a6839
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/batch_user_request.py
@@ -0,0 +1,43 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+
+
+class BatchUserRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.user_ids: Optional[List[str]] = None
+        self.user_id_type: Optional[str] = None
+        self.department_id_type: Optional[str] = None
+
+    @staticmethod
+    def builder() -> "BatchUserRequestBuilder":
+        return BatchUserRequestBuilder()
+
+
+class BatchUserRequestBuilder(object):
+
+    def __init__(self) -> None:
+        batch_user_request = BatchUserRequest()
+        batch_user_request.http_method = HttpMethod.GET
+        batch_user_request.uri = "/open-apis/contact/v3/users/batch"
+        batch_user_request.token_types = {AccessTokenType.TENANT, AccessTokenType.USER}
+        self._batch_user_request: BatchUserRequest = batch_user_request
+
+    def user_ids(self, user_ids: List[str]) -> "BatchUserRequestBuilder":
+        self._batch_user_request.user_ids = user_ids
+        self._batch_user_request.add_query("user_ids", user_ids)
+        return self
+
+    def user_id_type(self, user_id_type: str) -> "BatchUserRequestBuilder":
+        self._batch_user_request.user_id_type = user_id_type
+        self._batch_user_request.add_query("user_id_type", user_id_type)
+        return self
+
+    def department_id_type(self, department_id_type: str) -> "BatchUserRequestBuilder":
+        self._batch_user_request.department_id_type = department_id_type
+        self._batch_user_request.add_query("department_id_type", department_id_type)
+        return self
+
+    def build(self) -> BatchUserRequest:
+        return self._batch_user_request
diff --git a/lark_channel/api/contact/v3/model/batch_user_response.py b/lark_channel/api/contact/v3/model/batch_user_response.py
new file mode 100644
index 0000000..8aa73e7
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/batch_user_response.py
@@ -0,0 +1,15 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+from .batch_user_response_body import BatchUserResponseBody
+
+
+class BatchUserResponse(BaseResponse):
+    _types = {
+        "data": BatchUserResponseBody
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.data: Optional[BatchUserResponseBody] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/contact/v3/model/batch_user_response_body.py b/lark_channel/api/contact/v3/model/batch_user_response_body.py
new file mode 100644
index 0000000..6363225
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/batch_user_response_body.py
@@ -0,0 +1,29 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .user import User
+
+
+class BatchUserResponseBody(object):
+    _types = {
+        "items": List[User],
+    }
+
+    def __init__(self, d=None):
+        self.items: Optional[List[User]] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "BatchUserResponseBodyBuilder":
+        return BatchUserResponseBodyBuilder()
+
+
+class BatchUserResponseBodyBuilder(object):
+    def __init__(self) -> None:
+        self._batch_user_response_body = BatchUserResponseBody()
+
+    def items(self, items: List[User]) -> "BatchUserResponseBodyBuilder":
+        self._batch_user_response_body.items = items
+        return self
+
+    def build(self) -> "BatchUserResponseBody":
+        return self._batch_user_response_body
diff --git a/lark_channel/api/contact/v3/model/create_user_request.py b/lark_channel/api/contact/v3/model/create_user_request.py
new file mode 100644
index 0000000..1510cf0
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/create_user_request.py
@@ -0,0 +1,50 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .user import User
+
+
+class CreateUserRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.user_id_type: Optional[str] = None
+        self.department_id_type: Optional[str] = None
+        self.client_token: Optional[str] = None
+        self.request_body: Optional[User] = None
+
+    @staticmethod
+    def builder() -> "CreateUserRequestBuilder":
+        return CreateUserRequestBuilder()
+
+
+class CreateUserRequestBuilder(object):
+
+    def __init__(self) -> None:
+        create_user_request = CreateUserRequest()
+        create_user_request.http_method = HttpMethod.POST
+        create_user_request.uri = "/open-apis/contact/v3/users"
+        create_user_request.token_types = {AccessTokenType.TENANT}
+        self._create_user_request: CreateUserRequest = create_user_request
+
+    def user_id_type(self, user_id_type: str) -> "CreateUserRequestBuilder":
+        self._create_user_request.user_id_type = user_id_type
+        self._create_user_request.add_query("user_id_type", user_id_type)
+        return self
+
+    def department_id_type(self, department_id_type: str) -> "CreateUserRequestBuilder":
+        self._create_user_request.department_id_type = department_id_type
+        self._create_user_request.add_query("department_id_type", department_id_type)
+        return self
+
+    def client_token(self, client_token: str) -> "CreateUserRequestBuilder":
+        self._create_user_request.client_token = client_token
+        self._create_user_request.add_query("client_token", client_token)
+        return self
+
+    def request_body(self, request_body: User) -> "CreateUserRequestBuilder":
+        self._create_user_request.request_body = request_body
+        self._create_user_request.body = request_body
+        return self
+
+    def build(self) -> CreateUserRequest:
+        return self._create_user_request
diff --git a/lark_channel/api/contact/v3/model/create_user_response.py b/lark_channel/api/contact/v3/model/create_user_response.py
new file mode 100644
index 0000000..d617650
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/create_user_response.py
@@ -0,0 +1,15 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+from .create_user_response_body import CreateUserResponseBody
+
+
+class CreateUserResponse(BaseResponse):
+    _types = {
+        "data": CreateUserResponseBody
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.data: Optional[CreateUserResponseBody] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/contact/v3/model/create_user_response_body.py b/lark_channel/api/contact/v3/model/create_user_response_body.py
new file mode 100644
index 0000000..eead4c4
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/create_user_response_body.py
@@ -0,0 +1,29 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .user import User
+
+
+class CreateUserResponseBody(object):
+    _types = {
+        "user": User,
+    }
+
+    def __init__(self, d=None):
+        self.user: Optional[User] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "CreateUserResponseBodyBuilder":
+        return CreateUserResponseBodyBuilder()
+
+
+class CreateUserResponseBodyBuilder(object):
+    def __init__(self) -> None:
+        self._create_user_response_body = CreateUserResponseBody()
+
+    def user(self, user: User) -> "CreateUserResponseBodyBuilder":
+        self._create_user_response_body.user = user
+        return self
+
+    def build(self) -> "CreateUserResponseBody":
+        return self._create_user_response_body
diff --git a/lark_channel/api/contact/v3/model/custom_attr_generic_user.py b/lark_channel/api/contact/v3/model/custom_attr_generic_user.py
new file mode 100644
index 0000000..4dd900c
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/custom_attr_generic_user.py
@@ -0,0 +1,34 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class CustomAttrGenericUser(object):
+    _types = {
+        "id": str,
+        "type": int,
+    }
+
+    def __init__(self, d=None):
+        self.id: Optional[str] = None
+        self.type: Optional[int] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "CustomAttrGenericUserBuilder":
+        return CustomAttrGenericUserBuilder()
+
+
+class CustomAttrGenericUserBuilder(object):
+    def __init__(self) -> None:
+        self._custom_attr_generic_user = CustomAttrGenericUser()
+
+    def id(self, id: str) -> "CustomAttrGenericUserBuilder":
+        self._custom_attr_generic_user.id = id
+        return self
+
+    def type(self, type: int) -> "CustomAttrGenericUserBuilder":
+        self._custom_attr_generic_user.type = type
+        return self
+
+    def build(self) -> "CustomAttrGenericUser":
+        return self._custom_attr_generic_user
diff --git a/lark_channel/api/contact/v3/model/delete_user_request.py b/lark_channel/api/contact/v3/model/delete_user_request.py
new file mode 100644
index 0000000..470421c
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/delete_user_request.py
@@ -0,0 +1,44 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .delete_user_request_body import DeleteUserRequestBody
+
+
+class DeleteUserRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.user_id_type: Optional[str] = None
+        self.user_id: Optional[str] = None
+        self.request_body: Optional[DeleteUserRequestBody] = None
+
+    @staticmethod
+    def builder() -> "DeleteUserRequestBuilder":
+        return DeleteUserRequestBuilder()
+
+
+class DeleteUserRequestBuilder(object):
+
+    def __init__(self) -> None:
+        delete_user_request = DeleteUserRequest()
+        delete_user_request.http_method = HttpMethod.DELETE
+        delete_user_request.uri = "/open-apis/contact/v3/users/:user_id"
+        delete_user_request.token_types = {AccessTokenType.TENANT}
+        self._delete_user_request: DeleteUserRequest = delete_user_request
+
+    def user_id_type(self, user_id_type: str) -> "DeleteUserRequestBuilder":
+        self._delete_user_request.user_id_type = user_id_type
+        self._delete_user_request.add_query("user_id_type", user_id_type)
+        return self
+
+    def user_id(self, user_id: str) -> "DeleteUserRequestBuilder":
+        self._delete_user_request.user_id = user_id
+        self._delete_user_request.paths["user_id"] = str(user_id)
+        return self
+
+    def request_body(self, request_body: DeleteUserRequestBody) -> "DeleteUserRequestBuilder":
+        self._delete_user_request.request_body = request_body
+        self._delete_user_request.body = request_body
+        return self
+
+    def build(self) -> DeleteUserRequest:
+        return self._delete_user_request
diff --git a/lark_channel/api/contact/v3/model/delete_user_request_body.py b/lark_channel/api/contact/v3/model/delete_user_request_body.py
new file mode 100644
index 0000000..8f63f97
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/delete_user_request_body.py
@@ -0,0 +1,77 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .resource_acceptor import ResourceAcceptor
+
+
+class DeleteUserRequestBody(object):
+    _types = {
+        "department_chat_acceptor_user_id": str,
+        "external_chat_acceptor_user_id": str,
+        "docs_acceptor_user_id": str,
+        "calendar_acceptor_user_id": str,
+        "application_acceptor_user_id": str,
+        "minutes_acceptor_user_id": str,
+        "survey_acceptor_user_id": str,
+        "email_acceptor": ResourceAcceptor,
+        "anycross_acceptor_user_id": str,
+    }
+
+    def __init__(self, d=None):
+        self.department_chat_acceptor_user_id: Optional[str] = None
+        self.external_chat_acceptor_user_id: Optional[str] = None
+        self.docs_acceptor_user_id: Optional[str] = None
+        self.calendar_acceptor_user_id: Optional[str] = None
+        self.application_acceptor_user_id: Optional[str] = None
+        self.minutes_acceptor_user_id: Optional[str] = None
+        self.survey_acceptor_user_id: Optional[str] = None
+        self.email_acceptor: Optional[ResourceAcceptor] = None
+        self.anycross_acceptor_user_id: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "DeleteUserRequestBodyBuilder":
+        return DeleteUserRequestBodyBuilder()
+
+
+class DeleteUserRequestBodyBuilder(object):
+    def __init__(self) -> None:
+        self._delete_user_request_body = DeleteUserRequestBody()
+
+    def department_chat_acceptor_user_id(self, department_chat_acceptor_user_id: str) -> "DeleteUserRequestBodyBuilder":
+        self._delete_user_request_body.department_chat_acceptor_user_id = department_chat_acceptor_user_id
+        return self
+
+    def external_chat_acceptor_user_id(self, external_chat_acceptor_user_id: str) -> "DeleteUserRequestBodyBuilder":
+        self._delete_user_request_body.external_chat_acceptor_user_id = external_chat_acceptor_user_id
+        return self
+
+    def docs_acceptor_user_id(self, docs_acceptor_user_id: str) -> "DeleteUserRequestBodyBuilder":
+        self._delete_user_request_body.docs_acceptor_user_id = docs_acceptor_user_id
+        return self
+
+    def calendar_acceptor_user_id(self, calendar_acceptor_user_id: str) -> "DeleteUserRequestBodyBuilder":
+        self._delete_user_request_body.calendar_acceptor_user_id = calendar_acceptor_user_id
+        return self
+
+    def application_acceptor_user_id(self, application_acceptor_user_id: str) -> "DeleteUserRequestBodyBuilder":
+        self._delete_user_request_body.application_acceptor_user_id = application_acceptor_user_id
+        return self
+
+    def minutes_acceptor_user_id(self, minutes_acceptor_user_id: str) -> "DeleteUserRequestBodyBuilder":
+        self._delete_user_request_body.minutes_acceptor_user_id = minutes_acceptor_user_id
+        return self
+
+    def survey_acceptor_user_id(self, survey_acceptor_user_id: str) -> "DeleteUserRequestBodyBuilder":
+        self._delete_user_request_body.survey_acceptor_user_id = survey_acceptor_user_id
+        return self
+
+    def email_acceptor(self, email_acceptor: ResourceAcceptor) -> "DeleteUserRequestBodyBuilder":
+        self._delete_user_request_body.email_acceptor = email_acceptor
+        return self
+
+    def anycross_acceptor_user_id(self, anycross_acceptor_user_id: str) -> "DeleteUserRequestBodyBuilder":
+        self._delete_user_request_body.anycross_acceptor_user_id = anycross_acceptor_user_id
+        return self
+
+    def build(self) -> "DeleteUserRequestBody":
+        return self._delete_user_request_body
diff --git a/lark_channel/api/contact/v3/model/delete_user_response.py b/lark_channel/api/contact/v3/model/delete_user_response.py
new file mode 100644
index 0000000..f4f7512
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/delete_user_response.py
@@ -0,0 +1,14 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+
+
+class DeleteUserResponse(BaseResponse):
+    _types = {
+
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+
+        init(self, d, self._types)
diff --git a/lark_channel/api/contact/v3/model/department_detail.py b/lark_channel/api/contact/v3/model/department_detail.py
new file mode 100644
index 0000000..3891e68
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/department_detail.py
@@ -0,0 +1,42 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .department_path_name import DepartmentPathName
+from .department_path import DepartmentPath
+
+
+class DepartmentDetail(object):
+    _types = {
+        "department_id": int,
+        "department_name": DepartmentPathName,
+        "department_path": DepartmentPath,
+    }
+
+    def __init__(self, d=None):
+        self.department_id: Optional[int] = None
+        self.department_name: Optional[DepartmentPathName] = None
+        self.department_path: Optional[DepartmentPath] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "DepartmentDetailBuilder":
+        return DepartmentDetailBuilder()
+
+
+class DepartmentDetailBuilder(object):
+    def __init__(self) -> None:
+        self._department_detail = DepartmentDetail()
+
+    def department_id(self, department_id: int) -> "DepartmentDetailBuilder":
+        self._department_detail.department_id = department_id
+        return self
+
+    def department_name(self, department_name: DepartmentPathName) -> "DepartmentDetailBuilder":
+        self._department_detail.department_name = department_name
+        return self
+
+    def department_path(self, department_path: DepartmentPath) -> "DepartmentDetailBuilder":
+        self._department_detail.department_path = department_path
+        return self
+
+    def build(self) -> "DepartmentDetail":
+        return self._department_detail
diff --git a/lark_channel/api/contact/v3/model/department_i18n_name.py b/lark_channel/api/contact/v3/model/department_i18n_name.py
new file mode 100644
index 0000000..598e737
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/department_i18n_name.py
@@ -0,0 +1,40 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class DepartmentI18nName(object):
+    _types = {
+        "zh_cn": str,
+        "ja_jp": str,
+        "en_us": str,
+    }
+
+    def __init__(self, d=None):
+        self.zh_cn: Optional[str] = None
+        self.ja_jp: Optional[str] = None
+        self.en_us: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "DepartmentI18nNameBuilder":
+        return DepartmentI18nNameBuilder()
+
+
+class DepartmentI18nNameBuilder(object):
+    def __init__(self) -> None:
+        self._department_i18n_name = DepartmentI18nName()
+
+    def zh_cn(self, zh_cn: str) -> "DepartmentI18nNameBuilder":
+        self._department_i18n_name.zh_cn = zh_cn
+        return self
+
+    def ja_jp(self, ja_jp: str) -> "DepartmentI18nNameBuilder":
+        self._department_i18n_name.ja_jp = ja_jp
+        return self
+
+    def en_us(self, en_us: str) -> "DepartmentI18nNameBuilder":
+        self._department_i18n_name.en_us = en_us
+        return self
+
+    def build(self) -> "DepartmentI18nName":
+        return self._department_i18n_name
diff --git a/lark_channel/api/contact/v3/model/department_path.py b/lark_channel/api/contact/v3/model/department_path.py
new file mode 100644
index 0000000..e3a1957
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/department_path.py
@@ -0,0 +1,35 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .department_path_name import DepartmentPathName
+
+
+class DepartmentPath(object):
+    _types = {
+        "department_ids": List[str],
+        "department_path_name": DepartmentPathName,
+    }
+
+    def __init__(self, d=None):
+        self.department_ids: Optional[List[str]] = None
+        self.department_path_name: Optional[DepartmentPathName] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "DepartmentPathBuilder":
+        return DepartmentPathBuilder()
+
+
+class DepartmentPathBuilder(object):
+    def __init__(self) -> None:
+        self._department_path = DepartmentPath()
+
+    def department_ids(self, department_ids: List[str]) -> "DepartmentPathBuilder":
+        self._department_path.department_ids = department_ids
+        return self
+
+    def department_path_name(self, department_path_name: DepartmentPathName) -> "DepartmentPathBuilder":
+        self._department_path.department_path_name = department_path_name
+        return self
+
+    def build(self) -> "DepartmentPath":
+        return self._department_path
diff --git a/lark_channel/api/contact/v3/model/department_path_name.py b/lark_channel/api/contact/v3/model/department_path_name.py
new file mode 100644
index 0000000..d6d17dc
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/department_path_name.py
@@ -0,0 +1,35 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .department_i18n_name import DepartmentI18nName
+
+
+class DepartmentPathName(object):
+    _types = {
+        "name": str,
+        "i18n_name": DepartmentI18nName,
+    }
+
+    def __init__(self, d=None):
+        self.name: Optional[str] = None
+        self.i18n_name: Optional[DepartmentI18nName] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "DepartmentPathNameBuilder":
+        return DepartmentPathNameBuilder()
+
+
+class DepartmentPathNameBuilder(object):
+    def __init__(self) -> None:
+        self._department_path_name = DepartmentPathName()
+
+    def name(self, name: str) -> "DepartmentPathNameBuilder":
+        self._department_path_name.name = name
+        return self
+
+    def i18n_name(self, i18n_name: DepartmentI18nName) -> "DepartmentPathNameBuilder":
+        self._department_path_name.i18n_name = i18n_name
+        return self
+
+    def build(self) -> "DepartmentPathName":
+        return self._department_path_name
diff --git a/lark_channel/api/contact/v3/model/find_by_department_user_request.py b/lark_channel/api/contact/v3/model/find_by_department_user_request.py
new file mode 100644
index 0000000..7fe0304
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/find_by_department_user_request.py
@@ -0,0 +1,55 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+
+
+class FindByDepartmentUserRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.user_id_type: Optional[str] = None
+        self.department_id_type: Optional[str] = None
+        self.department_id: Optional[str] = None
+        self.page_size: Optional[int] = None
+        self.page_token: Optional[str] = None
+
+    @staticmethod
+    def builder() -> "FindByDepartmentUserRequestBuilder":
+        return FindByDepartmentUserRequestBuilder()
+
+
+class FindByDepartmentUserRequestBuilder(object):
+
+    def __init__(self) -> None:
+        find_by_department_user_request = FindByDepartmentUserRequest()
+        find_by_department_user_request.http_method = HttpMethod.GET
+        find_by_department_user_request.uri = "/open-apis/contact/v3/users/find_by_department"
+        find_by_department_user_request.token_types = {AccessTokenType.TENANT, AccessTokenType.USER}
+        self._find_by_department_user_request: FindByDepartmentUserRequest = find_by_department_user_request
+
+    def user_id_type(self, user_id_type: str) -> "FindByDepartmentUserRequestBuilder":
+        self._find_by_department_user_request.user_id_type = user_id_type
+        self._find_by_department_user_request.add_query("user_id_type", user_id_type)
+        return self
+
+    def department_id_type(self, department_id_type: str) -> "FindByDepartmentUserRequestBuilder":
+        self._find_by_department_user_request.department_id_type = department_id_type
+        self._find_by_department_user_request.add_query("department_id_type", department_id_type)
+        return self
+
+    def department_id(self, department_id: str) -> "FindByDepartmentUserRequestBuilder":
+        self._find_by_department_user_request.department_id = department_id
+        self._find_by_department_user_request.add_query("department_id", department_id)
+        return self
+
+    def page_size(self, page_size: int) -> "FindByDepartmentUserRequestBuilder":
+        self._find_by_department_user_request.page_size = page_size
+        self._find_by_department_user_request.add_query("page_size", page_size)
+        return self
+
+    def page_token(self, page_token: str) -> "FindByDepartmentUserRequestBuilder":
+        self._find_by_department_user_request.page_token = page_token
+        self._find_by_department_user_request.add_query("page_token", page_token)
+        return self
+
+    def build(self) -> FindByDepartmentUserRequest:
+        return self._find_by_department_user_request
diff --git a/lark_channel/api/contact/v3/model/find_by_department_user_response.py b/lark_channel/api/contact/v3/model/find_by_department_user_response.py
new file mode 100644
index 0000000..855fdc1
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/find_by_department_user_response.py
@@ -0,0 +1,15 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+from .find_by_department_user_response_body import FindByDepartmentUserResponseBody
+
+
+class FindByDepartmentUserResponse(BaseResponse):
+    _types = {
+        "data": FindByDepartmentUserResponseBody
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.data: Optional[FindByDepartmentUserResponseBody] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/contact/v3/model/find_by_department_user_response_body.py b/lark_channel/api/contact/v3/model/find_by_department_user_response_body.py
new file mode 100644
index 0000000..5547aa2
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/find_by_department_user_response_body.py
@@ -0,0 +1,41 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .user import User
+
+
+class FindByDepartmentUserResponseBody(object):
+    _types = {
+        "has_more": bool,
+        "page_token": str,
+        "items": List[User],
+    }
+
+    def __init__(self, d=None):
+        self.has_more: Optional[bool] = None
+        self.page_token: Optional[str] = None
+        self.items: Optional[List[User]] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "FindByDepartmentUserResponseBodyBuilder":
+        return FindByDepartmentUserResponseBodyBuilder()
+
+
+class FindByDepartmentUserResponseBodyBuilder(object):
+    def __init__(self) -> None:
+        self._find_by_department_user_response_body = FindByDepartmentUserResponseBody()
+
+    def has_more(self, has_more: bool) -> "FindByDepartmentUserResponseBodyBuilder":
+        self._find_by_department_user_response_body.has_more = has_more
+        return self
+
+    def page_token(self, page_token: str) -> "FindByDepartmentUserResponseBodyBuilder":
+        self._find_by_department_user_response_body.page_token = page_token
+        return self
+
+    def items(self, items: List[User]) -> "FindByDepartmentUserResponseBodyBuilder":
+        self._find_by_department_user_response_body.items = items
+        return self
+
+    def build(self) -> "FindByDepartmentUserResponseBody":
+        return self._find_by_department_user_response_body
diff --git a/lark_channel/api/contact/v3/model/get_user_request.py b/lark_channel/api/contact/v3/model/get_user_request.py
new file mode 100644
index 0000000..a8403b2
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/get_user_request.py
@@ -0,0 +1,43 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+
+
+class GetUserRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.user_id_type: Optional[str] = None
+        self.department_id_type: Optional[str] = None
+        self.user_id: Optional[str] = None
+
+    @staticmethod
+    def builder() -> "GetUserRequestBuilder":
+        return GetUserRequestBuilder()
+
+
+class GetUserRequestBuilder(object):
+
+    def __init__(self) -> None:
+        get_user_request = GetUserRequest()
+        get_user_request.http_method = HttpMethod.GET
+        get_user_request.uri = "/open-apis/contact/v3/users/:user_id"
+        get_user_request.token_types = {AccessTokenType.TENANT, AccessTokenType.USER}
+        self._get_user_request: GetUserRequest = get_user_request
+
+    def user_id_type(self, user_id_type: str) -> "GetUserRequestBuilder":
+        self._get_user_request.user_id_type = user_id_type
+        self._get_user_request.add_query("user_id_type", user_id_type)
+        return self
+
+    def department_id_type(self, department_id_type: str) -> "GetUserRequestBuilder":
+        self._get_user_request.department_id_type = department_id_type
+        self._get_user_request.add_query("department_id_type", department_id_type)
+        return self
+
+    def user_id(self, user_id: str) -> "GetUserRequestBuilder":
+        self._get_user_request.user_id = user_id
+        self._get_user_request.paths["user_id"] = str(user_id)
+        return self
+
+    def build(self) -> GetUserRequest:
+        return self._get_user_request
diff --git a/lark_channel/api/contact/v3/model/get_user_response.py b/lark_channel/api/contact/v3/model/get_user_response.py
new file mode 100644
index 0000000..d398ebe
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/get_user_response.py
@@ -0,0 +1,15 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+from .get_user_response_body import GetUserResponseBody
+
+
+class GetUserResponse(BaseResponse):
+    _types = {
+        "data": GetUserResponseBody
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.data: Optional[GetUserResponseBody] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/contact/v3/model/get_user_response_body.py b/lark_channel/api/contact/v3/model/get_user_response_body.py
new file mode 100644
index 0000000..67833d7
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/get_user_response_body.py
@@ -0,0 +1,29 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .user import User
+
+
+class GetUserResponseBody(object):
+    _types = {
+        "user": User,
+    }
+
+    def __init__(self, d=None):
+        self.user: Optional[User] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "GetUserResponseBodyBuilder":
+        return GetUserResponseBodyBuilder()
+
+
+class GetUserResponseBodyBuilder(object):
+    def __init__(self) -> None:
+        self._get_user_response_body = GetUserResponseBody()
+
+    def user(self, user: User) -> "GetUserResponseBodyBuilder":
+        self._get_user_response_body.user = user
+        return self
+
+    def build(self) -> "GetUserResponseBody":
+        return self._get_user_response_body
diff --git a/lark_channel/api/contact/v3/model/list_user_request.py b/lark_channel/api/contact/v3/model/list_user_request.py
new file mode 100644
index 0000000..fcef224
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/list_user_request.py
@@ -0,0 +1,55 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+
+
+class ListUserRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.user_id_type: Optional[str] = None
+        self.department_id_type: Optional[str] = None
+        self.department_id: Optional[str] = None
+        self.page_token: Optional[str] = None
+        self.page_size: Optional[int] = None
+
+    @staticmethod
+    def builder() -> "ListUserRequestBuilder":
+        return ListUserRequestBuilder()
+
+
+class ListUserRequestBuilder(object):
+
+    def __init__(self) -> None:
+        list_user_request = ListUserRequest()
+        list_user_request.http_method = HttpMethod.GET
+        list_user_request.uri = "/open-apis/contact/v3/users"
+        list_user_request.token_types = {AccessTokenType.TENANT, AccessTokenType.USER}
+        self._list_user_request: ListUserRequest = list_user_request
+
+    def user_id_type(self, user_id_type: str) -> "ListUserRequestBuilder":
+        self._list_user_request.user_id_type = user_id_type
+        self._list_user_request.add_query("user_id_type", user_id_type)
+        return self
+
+    def department_id_type(self, department_id_type: str) -> "ListUserRequestBuilder":
+        self._list_user_request.department_id_type = department_id_type
+        self._list_user_request.add_query("department_id_type", department_id_type)
+        return self
+
+    def department_id(self, department_id: str) -> "ListUserRequestBuilder":
+        self._list_user_request.department_id = department_id
+        self._list_user_request.add_query("department_id", department_id)
+        return self
+
+    def page_token(self, page_token: str) -> "ListUserRequestBuilder":
+        self._list_user_request.page_token = page_token
+        self._list_user_request.add_query("page_token", page_token)
+        return self
+
+    def page_size(self, page_size: int) -> "ListUserRequestBuilder":
+        self._list_user_request.page_size = page_size
+        self._list_user_request.add_query("page_size", page_size)
+        return self
+
+    def build(self) -> ListUserRequest:
+        return self._list_user_request
diff --git a/lark_channel/api/contact/v3/model/list_user_response.py b/lark_channel/api/contact/v3/model/list_user_response.py
new file mode 100644
index 0000000..662c721
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/list_user_response.py
@@ -0,0 +1,15 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+from .list_user_response_body import ListUserResponseBody
+
+
+class ListUserResponse(BaseResponse):
+    _types = {
+        "data": ListUserResponseBody
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.data: Optional[ListUserResponseBody] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/contact/v3/model/list_user_response_body.py b/lark_channel/api/contact/v3/model/list_user_response_body.py
new file mode 100644
index 0000000..a049b9d
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/list_user_response_body.py
@@ -0,0 +1,41 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .user import User
+
+
+class ListUserResponseBody(object):
+    _types = {
+        "has_more": bool,
+        "page_token": str,
+        "items": List[User],
+    }
+
+    def __init__(self, d=None):
+        self.has_more: Optional[bool] = None
+        self.page_token: Optional[str] = None
+        self.items: Optional[List[User]] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "ListUserResponseBodyBuilder":
+        return ListUserResponseBodyBuilder()
+
+
+class ListUserResponseBodyBuilder(object):
+    def __init__(self) -> None:
+        self._list_user_response_body = ListUserResponseBody()
+
+    def has_more(self, has_more: bool) -> "ListUserResponseBodyBuilder":
+        self._list_user_response_body.has_more = has_more
+        return self
+
+    def page_token(self, page_token: str) -> "ListUserResponseBodyBuilder":
+        self._list_user_response_body.page_token = page_token
+        return self
+
+    def items(self, items: List[User]) -> "ListUserResponseBodyBuilder":
+        self._list_user_response_body.items = items
+        return self
+
+    def build(self) -> "ListUserResponseBody":
+        return self._list_user_response_body
diff --git a/lark_channel/api/contact/v3/model/notification_option.py b/lark_channel/api/contact/v3/model/notification_option.py
new file mode 100644
index 0000000..ab0ad9e
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/notification_option.py
@@ -0,0 +1,34 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class NotificationOption(object):
+    _types = {
+        "channels": List[str],
+        "language": str,
+    }
+
+    def __init__(self, d=None):
+        self.channels: Optional[List[str]] = None
+        self.language: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "NotificationOptionBuilder":
+        return NotificationOptionBuilder()
+
+
+class NotificationOptionBuilder(object):
+    def __init__(self) -> None:
+        self._notification_option = NotificationOption()
+
+    def channels(self, channels: List[str]) -> "NotificationOptionBuilder":
+        self._notification_option.channels = channels
+        return self
+
+    def language(self, language: str) -> "NotificationOptionBuilder":
+        self._notification_option.language = language
+        return self
+
+    def build(self) -> "NotificationOption":
+        return self._notification_option
diff --git a/lark_channel/api/contact/v3/model/patch_user_request.py b/lark_channel/api/contact/v3/model/patch_user_request.py
new file mode 100644
index 0000000..4097bc5
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/patch_user_request.py
@@ -0,0 +1,50 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .user import User
+
+
+class PatchUserRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.user_id_type: Optional[str] = None
+        self.department_id_type: Optional[str] = None
+        self.user_id: Optional[str] = None
+        self.request_body: Optional[User] = None
+
+    @staticmethod
+    def builder() -> "PatchUserRequestBuilder":
+        return PatchUserRequestBuilder()
+
+
+class PatchUserRequestBuilder(object):
+
+    def __init__(self) -> None:
+        patch_user_request = PatchUserRequest()
+        patch_user_request.http_method = HttpMethod.PATCH
+        patch_user_request.uri = "/open-apis/contact/v3/users/:user_id"
+        patch_user_request.token_types = {AccessTokenType.TENANT, AccessTokenType.USER}
+        self._patch_user_request: PatchUserRequest = patch_user_request
+
+    def user_id_type(self, user_id_type: str) -> "PatchUserRequestBuilder":
+        self._patch_user_request.user_id_type = user_id_type
+        self._patch_user_request.add_query("user_id_type", user_id_type)
+        return self
+
+    def department_id_type(self, department_id_type: str) -> "PatchUserRequestBuilder":
+        self._patch_user_request.department_id_type = department_id_type
+        self._patch_user_request.add_query("department_id_type", department_id_type)
+        return self
+
+    def user_id(self, user_id: str) -> "PatchUserRequestBuilder":
+        self._patch_user_request.user_id = user_id
+        self._patch_user_request.paths["user_id"] = str(user_id)
+        return self
+
+    def request_body(self, request_body: User) -> "PatchUserRequestBuilder":
+        self._patch_user_request.request_body = request_body
+        self._patch_user_request.body = request_body
+        return self
+
+    def build(self) -> PatchUserRequest:
+        return self._patch_user_request
diff --git a/lark_channel/api/contact/v3/model/patch_user_response.py b/lark_channel/api/contact/v3/model/patch_user_response.py
new file mode 100644
index 0000000..fe19cc1
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/patch_user_response.py
@@ -0,0 +1,15 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+from .patch_user_response_body import PatchUserResponseBody
+
+
+class PatchUserResponse(BaseResponse):
+    _types = {
+        "data": PatchUserResponseBody
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.data: Optional[PatchUserResponseBody] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/contact/v3/model/patch_user_response_body.py b/lark_channel/api/contact/v3/model/patch_user_response_body.py
new file mode 100644
index 0000000..702fb14
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/patch_user_response_body.py
@@ -0,0 +1,29 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .user import User
+
+
+class PatchUserResponseBody(object):
+    _types = {
+        "user": User,
+    }
+
+    def __init__(self, d=None):
+        self.user: Optional[User] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "PatchUserResponseBodyBuilder":
+        return PatchUserResponseBodyBuilder()
+
+
+class PatchUserResponseBodyBuilder(object):
+    def __init__(self) -> None:
+        self._patch_user_response_body = PatchUserResponseBody()
+
+    def user(self, user: User) -> "PatchUserResponseBodyBuilder":
+        self._patch_user_response_body.user = user
+        return self
+
+    def build(self) -> "PatchUserResponseBody":
+        return self._patch_user_response_body
diff --git a/lark_channel/api/contact/v3/model/product_i18n_name.py b/lark_channel/api/contact/v3/model/product_i18n_name.py
new file mode 100644
index 0000000..17bc3fe
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/product_i18n_name.py
@@ -0,0 +1,40 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class ProductI18nName(object):
+    _types = {
+        "zh_cn": str,
+        "ja_jp": str,
+        "en_us": str,
+    }
+
+    def __init__(self, d=None):
+        self.zh_cn: Optional[str] = None
+        self.ja_jp: Optional[str] = None
+        self.en_us: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "ProductI18nNameBuilder":
+        return ProductI18nNameBuilder()
+
+
+class ProductI18nNameBuilder(object):
+    def __init__(self) -> None:
+        self._product_i18n_name = ProductI18nName()
+
+    def zh_cn(self, zh_cn: str) -> "ProductI18nNameBuilder":
+        self._product_i18n_name.zh_cn = zh_cn
+        return self
+
+    def ja_jp(self, ja_jp: str) -> "ProductI18nNameBuilder":
+        self._product_i18n_name.ja_jp = ja_jp
+        return self
+
+    def en_us(self, en_us: str) -> "ProductI18nNameBuilder":
+        self._product_i18n_name.en_us = en_us
+        return self
+
+    def build(self) -> "ProductI18nName":
+        return self._product_i18n_name
diff --git a/lark_channel/api/contact/v3/model/resource_acceptor.py b/lark_channel/api/contact/v3/model/resource_acceptor.py
new file mode 100644
index 0000000..2841064
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/resource_acceptor.py
@@ -0,0 +1,34 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class ResourceAcceptor(object):
+    _types = {
+        "processing_type": int,
+        "acceptor_user_id": int,
+    }
+
+    def __init__(self, d=None):
+        self.processing_type: Optional[int] = None
+        self.acceptor_user_id: Optional[int] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "ResourceAcceptorBuilder":
+        return ResourceAcceptorBuilder()
+
+
+class ResourceAcceptorBuilder(object):
+    def __init__(self) -> None:
+        self._resource_acceptor = ResourceAcceptor()
+
+    def processing_type(self, processing_type: int) -> "ResourceAcceptorBuilder":
+        self._resource_acceptor.processing_type = processing_type
+        return self
+
+    def acceptor_user_id(self, acceptor_user_id: int) -> "ResourceAcceptorBuilder":
+        self._resource_acceptor.acceptor_user_id = acceptor_user_id
+        return self
+
+    def build(self) -> "ResourceAcceptor":
+        return self._resource_acceptor
diff --git a/lark_channel/api/contact/v3/model/resurrect_user_request.py b/lark_channel/api/contact/v3/model/resurrect_user_request.py
new file mode 100644
index 0000000..9eb364e
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/resurrect_user_request.py
@@ -0,0 +1,50 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .resurrect_user_request_body import ResurrectUserRequestBody
+
+
+class ResurrectUserRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.user_id_type: Optional[str] = None
+        self.department_id_type: Optional[str] = None
+        self.user_id: Optional[int] = None
+        self.request_body: Optional[ResurrectUserRequestBody] = None
+
+    @staticmethod
+    def builder() -> "ResurrectUserRequestBuilder":
+        return ResurrectUserRequestBuilder()
+
+
+class ResurrectUserRequestBuilder(object):
+
+    def __init__(self) -> None:
+        resurrect_user_request = ResurrectUserRequest()
+        resurrect_user_request.http_method = HttpMethod.POST
+        resurrect_user_request.uri = "/open-apis/contact/v3/users/:user_id/resurrect"
+        resurrect_user_request.token_types = {AccessTokenType.TENANT}
+        self._resurrect_user_request: ResurrectUserRequest = resurrect_user_request
+
+    def user_id_type(self, user_id_type: str) -> "ResurrectUserRequestBuilder":
+        self._resurrect_user_request.user_id_type = user_id_type
+        self._resurrect_user_request.add_query("user_id_type", user_id_type)
+        return self
+
+    def department_id_type(self, department_id_type: str) -> "ResurrectUserRequestBuilder":
+        self._resurrect_user_request.department_id_type = department_id_type
+        self._resurrect_user_request.add_query("department_id_type", department_id_type)
+        return self
+
+    def user_id(self, user_id: int) -> "ResurrectUserRequestBuilder":
+        self._resurrect_user_request.user_id = user_id
+        self._resurrect_user_request.paths["user_id"] = str(user_id)
+        return self
+
+    def request_body(self, request_body: ResurrectUserRequestBody) -> "ResurrectUserRequestBuilder":
+        self._resurrect_user_request.request_body = request_body
+        self._resurrect_user_request.body = request_body
+        return self
+
+    def build(self) -> ResurrectUserRequest:
+        return self._resurrect_user_request
diff --git a/lark_channel/api/contact/v3/model/resurrect_user_request_body.py b/lark_channel/api/contact/v3/model/resurrect_user_request_body.py
new file mode 100644
index 0000000..a8d5a12
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/resurrect_user_request_body.py
@@ -0,0 +1,35 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .user_department_info import UserDepartmentInfo
+
+
+class ResurrectUserRequestBody(object):
+    _types = {
+        "departments": List[UserDepartmentInfo],
+        "subscription_ids": List[int],
+    }
+
+    def __init__(self, d=None):
+        self.departments: Optional[List[UserDepartmentInfo]] = None
+        self.subscription_ids: Optional[List[int]] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "ResurrectUserRequestBodyBuilder":
+        return ResurrectUserRequestBodyBuilder()
+
+
+class ResurrectUserRequestBodyBuilder(object):
+    def __init__(self) -> None:
+        self._resurrect_user_request_body = ResurrectUserRequestBody()
+
+    def departments(self, departments: List[UserDepartmentInfo]) -> "ResurrectUserRequestBodyBuilder":
+        self._resurrect_user_request_body.departments = departments
+        return self
+
+    def subscription_ids(self, subscription_ids: List[int]) -> "ResurrectUserRequestBodyBuilder":
+        self._resurrect_user_request_body.subscription_ids = subscription_ids
+        return self
+
+    def build(self) -> "ResurrectUserRequestBody":
+        return self._resurrect_user_request_body
diff --git a/lark_channel/api/contact/v3/model/resurrect_user_response.py b/lark_channel/api/contact/v3/model/resurrect_user_response.py
new file mode 100644
index 0000000..3289844
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/resurrect_user_response.py
@@ -0,0 +1,14 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+
+
+class ResurrectUserResponse(BaseResponse):
+    _types = {
+
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+
+        init(self, d, self._types)
diff --git a/lark_channel/api/contact/v3/model/update_user_id_user_request.py b/lark_channel/api/contact/v3/model/update_user_id_user_request.py
new file mode 100644
index 0000000..a4bc78b
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/update_user_id_user_request.py
@@ -0,0 +1,44 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .update_user_id_user_request_body import UpdateUserIdUserRequestBody
+
+
+class UpdateUserIdUserRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.user_id_type: Optional[str] = None
+        self.user_id: Optional[str] = None
+        self.request_body: Optional[UpdateUserIdUserRequestBody] = None
+
+    @staticmethod
+    def builder() -> "UpdateUserIdUserRequestBuilder":
+        return UpdateUserIdUserRequestBuilder()
+
+
+class UpdateUserIdUserRequestBuilder(object):
+
+    def __init__(self) -> None:
+        update_user_id_user_request = UpdateUserIdUserRequest()
+        update_user_id_user_request.http_method = HttpMethod.PATCH
+        update_user_id_user_request.uri = "/open-apis/contact/v3/users/:user_id/update_user_id"
+        update_user_id_user_request.token_types = {AccessTokenType.TENANT}
+        self._update_user_id_user_request: UpdateUserIdUserRequest = update_user_id_user_request
+
+    def user_id_type(self, user_id_type: str) -> "UpdateUserIdUserRequestBuilder":
+        self._update_user_id_user_request.user_id_type = user_id_type
+        self._update_user_id_user_request.add_query("user_id_type", user_id_type)
+        return self
+
+    def user_id(self, user_id: str) -> "UpdateUserIdUserRequestBuilder":
+        self._update_user_id_user_request.user_id = user_id
+        self._update_user_id_user_request.paths["user_id"] = str(user_id)
+        return self
+
+    def request_body(self, request_body: UpdateUserIdUserRequestBody) -> "UpdateUserIdUserRequestBuilder":
+        self._update_user_id_user_request.request_body = request_body
+        self._update_user_id_user_request.body = request_body
+        return self
+
+    def build(self) -> UpdateUserIdUserRequest:
+        return self._update_user_id_user_request
diff --git a/lark_channel/api/contact/v3/model/update_user_id_user_request_body.py b/lark_channel/api/contact/v3/model/update_user_id_user_request_body.py
new file mode 100644
index 0000000..0d58e16
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/update_user_id_user_request_body.py
@@ -0,0 +1,28 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class UpdateUserIdUserRequestBody(object):
+    _types = {
+        "new_user_id": str,
+    }
+
+    def __init__(self, d=None):
+        self.new_user_id: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "UpdateUserIdUserRequestBodyBuilder":
+        return UpdateUserIdUserRequestBodyBuilder()
+
+
+class UpdateUserIdUserRequestBodyBuilder(object):
+    def __init__(self) -> None:
+        self._update_user_id_user_request_body = UpdateUserIdUserRequestBody()
+
+    def new_user_id(self, new_user_id: str) -> "UpdateUserIdUserRequestBodyBuilder":
+        self._update_user_id_user_request_body.new_user_id = new_user_id
+        return self
+
+    def build(self) -> "UpdateUserIdUserRequestBody":
+        return self._update_user_id_user_request_body
diff --git a/lark_channel/api/contact/v3/model/update_user_id_user_response.py b/lark_channel/api/contact/v3/model/update_user_id_user_response.py
new file mode 100644
index 0000000..141b186
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/update_user_id_user_response.py
@@ -0,0 +1,14 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+
+
+class UpdateUserIdUserResponse(BaseResponse):
+    _types = {
+
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+
+        init(self, d, self._types)
diff --git a/lark_channel/api/contact/v3/model/update_user_request.py b/lark_channel/api/contact/v3/model/update_user_request.py
new file mode 100644
index 0000000..f0cbc8e
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/update_user_request.py
@@ -0,0 +1,50 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .user import User
+
+
+class UpdateUserRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.user_id_type: Optional[str] = None
+        self.department_id_type: Optional[str] = None
+        self.user_id: Optional[str] = None
+        self.request_body: Optional[User] = None
+
+    @staticmethod
+    def builder() -> "UpdateUserRequestBuilder":
+        return UpdateUserRequestBuilder()
+
+
+class UpdateUserRequestBuilder(object):
+
+    def __init__(self) -> None:
+        update_user_request = UpdateUserRequest()
+        update_user_request.http_method = HttpMethod.PUT
+        update_user_request.uri = "/open-apis/contact/v3/users/:user_id"
+        update_user_request.token_types = {AccessTokenType.TENANT}
+        self._update_user_request: UpdateUserRequest = update_user_request
+
+    def user_id_type(self, user_id_type: str) -> "UpdateUserRequestBuilder":
+        self._update_user_request.user_id_type = user_id_type
+        self._update_user_request.add_query("user_id_type", user_id_type)
+        return self
+
+    def department_id_type(self, department_id_type: str) -> "UpdateUserRequestBuilder":
+        self._update_user_request.department_id_type = department_id_type
+        self._update_user_request.add_query("department_id_type", department_id_type)
+        return self
+
+    def user_id(self, user_id: str) -> "UpdateUserRequestBuilder":
+        self._update_user_request.user_id = user_id
+        self._update_user_request.paths["user_id"] = str(user_id)
+        return self
+
+    def request_body(self, request_body: User) -> "UpdateUserRequestBuilder":
+        self._update_user_request.request_body = request_body
+        self._update_user_request.body = request_body
+        return self
+
+    def build(self) -> UpdateUserRequest:
+        return self._update_user_request
diff --git a/lark_channel/api/contact/v3/model/update_user_response.py b/lark_channel/api/contact/v3/model/update_user_response.py
new file mode 100644
index 0000000..a123262
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/update_user_response.py
@@ -0,0 +1,15 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+from .update_user_response_body import UpdateUserResponseBody
+
+
+class UpdateUserResponse(BaseResponse):
+    _types = {
+        "data": UpdateUserResponseBody
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.data: Optional[UpdateUserResponseBody] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/contact/v3/model/update_user_response_body.py b/lark_channel/api/contact/v3/model/update_user_response_body.py
new file mode 100644
index 0000000..0662752
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/update_user_response_body.py
@@ -0,0 +1,29 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .user import User
+
+
+class UpdateUserResponseBody(object):
+    _types = {
+        "user": User,
+    }
+
+    def __init__(self, d=None):
+        self.user: Optional[User] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "UpdateUserResponseBodyBuilder":
+        return UpdateUserResponseBodyBuilder()
+
+
+class UpdateUserResponseBodyBuilder(object):
+    def __init__(self) -> None:
+        self._update_user_response_body = UpdateUserResponseBody()
+
+    def user(self, user: User) -> "UpdateUserResponseBodyBuilder":
+        self._update_user_response_body.user = user
+        return self
+
+    def build(self) -> "UpdateUserResponseBody":
+        return self._update_user_response_body
diff --git a/lark_channel/api/contact/v3/model/user.py b/lark_channel/api/contact/v3/model/user.py
new file mode 100644
index 0000000..82c9cce
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/user.py
@@ -0,0 +1,270 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .avatar_info import AvatarInfo
+from .user_status import UserStatus
+from .user_position import UserPosition
+from .user_order import UserOrder
+from .user_custom_attr import UserCustomAttr
+from .notification_option import NotificationOption
+from .user_assign_info import UserAssignInfo
+from .department_detail import DepartmentDetail
+
+
+class User(object):
+    _types = {
+        "union_id": str,
+        "user_id": str,
+        "open_id": str,
+        "name": str,
+        "en_name": str,
+        "nickname": str,
+        "email": str,
+        "mobile": str,
+        "mobile_visible": bool,
+        "gender": int,
+        "avatar_key": str,
+        "avatar": AvatarInfo,
+        "status": UserStatus,
+        "department_ids": List[str],
+        "leader_user_id": str,
+        "city": str,
+        "country": str,
+        "work_station": str,
+        "join_time": int,
+        "is_tenant_manager": bool,
+        "employee_no": str,
+        "employee_type": int,
+        "positions": List[UserPosition],
+        "orders": List[UserOrder],
+        "custom_attrs": List[UserCustomAttr],
+        "enterprise_email": str,
+        "idp_type": str,
+        "time_zone": str,
+        "description": str,
+        "job_title": str,
+        "need_send_notification": bool,
+        "notification_option": NotificationOption,
+        "is_frozen": bool,
+        "geo": str,
+        "job_level_id": str,
+        "job_family_id": str,
+        "subscription_ids": List[int],
+        "assign_info": List[UserAssignInfo],
+        "department_path": List[DepartmentDetail],
+        "dotted_line_leader_user_ids": List[int],
+    }
+
+    def __init__(self, d=None):
+        self.union_id: Optional[str] = None
+        self.user_id: Optional[str] = None
+        self.open_id: Optional[str] = None
+        self.name: Optional[str] = None
+        self.en_name: Optional[str] = None
+        self.nickname: Optional[str] = None
+        self.email: Optional[str] = None
+        self.mobile: Optional[str] = None
+        self.mobile_visible: Optional[bool] = None
+        self.gender: Optional[int] = None
+        self.avatar_key: Optional[str] = None
+        self.avatar: Optional[AvatarInfo] = None
+        self.status: Optional[UserStatus] = None
+        self.department_ids: Optional[List[str]] = None
+        self.leader_user_id: Optional[str] = None
+        self.city: Optional[str] = None
+        self.country: Optional[str] = None
+        self.work_station: Optional[str] = None
+        self.join_time: Optional[int] = None
+        self.is_tenant_manager: Optional[bool] = None
+        self.employee_no: Optional[str] = None
+        self.employee_type: Optional[int] = None
+        self.positions: Optional[List[UserPosition]] = None
+        self.orders: Optional[List[UserOrder]] = None
+        self.custom_attrs: Optional[List[UserCustomAttr]] = None
+        self.enterprise_email: Optional[str] = None
+        self.idp_type: Optional[str] = None
+        self.time_zone: Optional[str] = None
+        self.description: Optional[str] = None
+        self.job_title: Optional[str] = None
+        self.need_send_notification: Optional[bool] = None
+        self.notification_option: Optional[NotificationOption] = None
+        self.is_frozen: Optional[bool] = None
+        self.geo: Optional[str] = None
+        self.job_level_id: Optional[str] = None
+        self.job_family_id: Optional[str] = None
+        self.subscription_ids: Optional[List[int]] = None
+        self.assign_info: Optional[List[UserAssignInfo]] = None
+        self.department_path: Optional[List[DepartmentDetail]] = None
+        self.dotted_line_leader_user_ids: Optional[List[int]] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "UserBuilder":
+        return UserBuilder()
+
+
+class UserBuilder(object):
+    def __init__(self) -> None:
+        self._user = User()
+
+    def union_id(self, union_id: str) -> "UserBuilder":
+        self._user.union_id = union_id
+        return self
+
+    def user_id(self, user_id: str) -> "UserBuilder":
+        self._user.user_id = user_id
+        return self
+
+    def open_id(self, open_id: str) -> "UserBuilder":
+        self._user.open_id = open_id
+        return self
+
+    def name(self, name: str) -> "UserBuilder":
+        self._user.name = name
+        return self
+
+    def en_name(self, en_name: str) -> "UserBuilder":
+        self._user.en_name = en_name
+        return self
+
+    def nickname(self, nickname: str) -> "UserBuilder":
+        self._user.nickname = nickname
+        return self
+
+    def email(self, email: str) -> "UserBuilder":
+        self._user.email = email
+        return self
+
+    def mobile(self, mobile: str) -> "UserBuilder":
+        self._user.mobile = mobile
+        return self
+
+    def mobile_visible(self, mobile_visible: bool) -> "UserBuilder":
+        self._user.mobile_visible = mobile_visible
+        return self
+
+    def gender(self, gender: int) -> "UserBuilder":
+        self._user.gender = gender
+        return self
+
+    def avatar_key(self, avatar_key: str) -> "UserBuilder":
+        self._user.avatar_key = avatar_key
+        return self
+
+    def avatar(self, avatar: AvatarInfo) -> "UserBuilder":
+        self._user.avatar = avatar
+        return self
+
+    def status(self, status: UserStatus) -> "UserBuilder":
+        self._user.status = status
+        return self
+
+    def department_ids(self, department_ids: List[str]) -> "UserBuilder":
+        self._user.department_ids = department_ids
+        return self
+
+    def leader_user_id(self, leader_user_id: str) -> "UserBuilder":
+        self._user.leader_user_id = leader_user_id
+        return self
+
+    def city(self, city: str) -> "UserBuilder":
+        self._user.city = city
+        return self
+
+    def country(self, country: str) -> "UserBuilder":
+        self._user.country = country
+        return self
+
+    def work_station(self, work_station: str) -> "UserBuilder":
+        self._user.work_station = work_station
+        return self
+
+    def join_time(self, join_time: int) -> "UserBuilder":
+        self._user.join_time = join_time
+        return self
+
+    def is_tenant_manager(self, is_tenant_manager: bool) -> "UserBuilder":
+        self._user.is_tenant_manager = is_tenant_manager
+        return self
+
+    def employee_no(self, employee_no: str) -> "UserBuilder":
+        self._user.employee_no = employee_no
+        return self
+
+    def employee_type(self, employee_type: int) -> "UserBuilder":
+        self._user.employee_type = employee_type
+        return self
+
+    def positions(self, positions: List[UserPosition]) -> "UserBuilder":
+        self._user.positions = positions
+        return self
+
+    def orders(self, orders: List[UserOrder]) -> "UserBuilder":
+        self._user.orders = orders
+        return self
+
+    def custom_attrs(self, custom_attrs: List[UserCustomAttr]) -> "UserBuilder":
+        self._user.custom_attrs = custom_attrs
+        return self
+
+    def enterprise_email(self, enterprise_email: str) -> "UserBuilder":
+        self._user.enterprise_email = enterprise_email
+        return self
+
+    def idp_type(self, idp_type: str) -> "UserBuilder":
+        self._user.idp_type = idp_type
+        return self
+
+    def time_zone(self, time_zone: str) -> "UserBuilder":
+        self._user.time_zone = time_zone
+        return self
+
+    def description(self, description: str) -> "UserBuilder":
+        self._user.description = description
+        return self
+
+    def job_title(self, job_title: str) -> "UserBuilder":
+        self._user.job_title = job_title
+        return self
+
+    def need_send_notification(self, need_send_notification: bool) -> "UserBuilder":
+        self._user.need_send_notification = need_send_notification
+        return self
+
+    def notification_option(self, notification_option: NotificationOption) -> "UserBuilder":
+        self._user.notification_option = notification_option
+        return self
+
+    def is_frozen(self, is_frozen: bool) -> "UserBuilder":
+        self._user.is_frozen = is_frozen
+        return self
+
+    def geo(self, geo: str) -> "UserBuilder":
+        self._user.geo = geo
+        return self
+
+    def job_level_id(self, job_level_id: str) -> "UserBuilder":
+        self._user.job_level_id = job_level_id
+        return self
+
+    def job_family_id(self, job_family_id: str) -> "UserBuilder":
+        self._user.job_family_id = job_family_id
+        return self
+
+    def subscription_ids(self, subscription_ids: List[int]) -> "UserBuilder":
+        self._user.subscription_ids = subscription_ids
+        return self
+
+    def assign_info(self, assign_info: List[UserAssignInfo]) -> "UserBuilder":
+        self._user.assign_info = assign_info
+        return self
+
+    def department_path(self, department_path: List[DepartmentDetail]) -> "UserBuilder":
+        self._user.department_path = department_path
+        return self
+
+    def dotted_line_leader_user_ids(self, dotted_line_leader_user_ids: List[int]) -> "UserBuilder":
+        self._user.dotted_line_leader_user_ids = dotted_line_leader_user_ids
+        return self
+
+    def build(self) -> "User":
+        return self._user
diff --git a/lark_channel/api/contact/v3/model/user_assign_info.py b/lark_channel/api/contact/v3/model/user_assign_info.py
new file mode 100644
index 0000000..a289559
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/user_assign_info.py
@@ -0,0 +1,59 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .product_i18n_name import ProductI18nName
+
+
+class UserAssignInfo(object):
+    _types = {
+        "subscription_id": int,
+        "license_plan_key": str,
+        "product_name": str,
+        "i18n_name": ProductI18nName,
+        "start_time": int,
+        "end_time": int,
+    }
+
+    def __init__(self, d=None):
+        self.subscription_id: Optional[int] = None
+        self.license_plan_key: Optional[str] = None
+        self.product_name: Optional[str] = None
+        self.i18n_name: Optional[ProductI18nName] = None
+        self.start_time: Optional[int] = None
+        self.end_time: Optional[int] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "UserAssignInfoBuilder":
+        return UserAssignInfoBuilder()
+
+
+class UserAssignInfoBuilder(object):
+    def __init__(self) -> None:
+        self._user_assign_info = UserAssignInfo()
+
+    def subscription_id(self, subscription_id: int) -> "UserAssignInfoBuilder":
+        self._user_assign_info.subscription_id = subscription_id
+        return self
+
+    def license_plan_key(self, license_plan_key: str) -> "UserAssignInfoBuilder":
+        self._user_assign_info.license_plan_key = license_plan_key
+        return self
+
+    def product_name(self, product_name: str) -> "UserAssignInfoBuilder":
+        self._user_assign_info.product_name = product_name
+        return self
+
+    def i18n_name(self, i18n_name: ProductI18nName) -> "UserAssignInfoBuilder":
+        self._user_assign_info.i18n_name = i18n_name
+        return self
+
+    def start_time(self, start_time: int) -> "UserAssignInfoBuilder":
+        self._user_assign_info.start_time = start_time
+        return self
+
+    def end_time(self, end_time: int) -> "UserAssignInfoBuilder":
+        self._user_assign_info.end_time = end_time
+        return self
+
+    def build(self) -> "UserAssignInfo":
+        return self._user_assign_info
diff --git a/lark_channel/api/contact/v3/model/user_contact_info.py b/lark_channel/api/contact/v3/model/user_contact_info.py
new file mode 100644
index 0000000..fe26a14
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/user_contact_info.py
@@ -0,0 +1,47 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .user_status import UserStatus
+
+
+class UserContactInfo(object):
+    _types = {
+        "user_id": str,
+        "mobile": str,
+        "email": str,
+        "status": UserStatus,
+    }
+
+    def __init__(self, d=None):
+        self.user_id: Optional[str] = None
+        self.mobile: Optional[str] = None
+        self.email: Optional[str] = None
+        self.status: Optional[UserStatus] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "UserContactInfoBuilder":
+        return UserContactInfoBuilder()
+
+
+class UserContactInfoBuilder(object):
+    def __init__(self) -> None:
+        self._user_contact_info = UserContactInfo()
+
+    def user_id(self, user_id: str) -> "UserContactInfoBuilder":
+        self._user_contact_info.user_id = user_id
+        return self
+
+    def mobile(self, mobile: str) -> "UserContactInfoBuilder":
+        self._user_contact_info.mobile = mobile
+        return self
+
+    def email(self, email: str) -> "UserContactInfoBuilder":
+        self._user_contact_info.email = email
+        return self
+
+    def status(self, status: UserStatus) -> "UserContactInfoBuilder":
+        self._user_contact_info.status = status
+        return self
+
+    def build(self) -> "UserContactInfo":
+        return self._user_contact_info
diff --git a/lark_channel/api/contact/v3/model/user_custom_attr.py b/lark_channel/api/contact/v3/model/user_custom_attr.py
new file mode 100644
index 0000000..bdd21e0
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/user_custom_attr.py
@@ -0,0 +1,41 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .user_custom_attr_value import UserCustomAttrValue
+
+
+class UserCustomAttr(object):
+    _types = {
+        "type": str,
+        "id": str,
+        "value": UserCustomAttrValue,
+    }
+
+    def __init__(self, d=None):
+        self.type: Optional[str] = None
+        self.id: Optional[str] = None
+        self.value: Optional[UserCustomAttrValue] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "UserCustomAttrBuilder":
+        return UserCustomAttrBuilder()
+
+
+class UserCustomAttrBuilder(object):
+    def __init__(self) -> None:
+        self._user_custom_attr = UserCustomAttr()
+
+    def type(self, type: str) -> "UserCustomAttrBuilder":
+        self._user_custom_attr.type = type
+        return self
+
+    def id(self, id: str) -> "UserCustomAttrBuilder":
+        self._user_custom_attr.id = id
+        return self
+
+    def value(self, value: UserCustomAttrValue) -> "UserCustomAttrBuilder":
+        self._user_custom_attr.value = value
+        return self
+
+    def build(self) -> "UserCustomAttr":
+        return self._user_custom_attr
diff --git a/lark_channel/api/contact/v3/model/user_custom_attr_value.py b/lark_channel/api/contact/v3/model/user_custom_attr_value.py
new file mode 100644
index 0000000..ccc2ae9
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/user_custom_attr_value.py
@@ -0,0 +1,71 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .custom_attr_generic_user import CustomAttrGenericUser
+
+
+class UserCustomAttrValue(object):
+    _types = {
+        "text": str,
+        "url": str,
+        "pc_url": str,
+        "option_id": str,
+        "option_value": str,
+        "name": str,
+        "picture_url": str,
+        "generic_user": CustomAttrGenericUser,
+    }
+
+    def __init__(self, d=None):
+        self.text: Optional[str] = None
+        self.url: Optional[str] = None
+        self.pc_url: Optional[str] = None
+        self.option_id: Optional[str] = None
+        self.option_value: Optional[str] = None
+        self.name: Optional[str] = None
+        self.picture_url: Optional[str] = None
+        self.generic_user: Optional[CustomAttrGenericUser] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "UserCustomAttrValueBuilder":
+        return UserCustomAttrValueBuilder()
+
+
+class UserCustomAttrValueBuilder(object):
+    def __init__(self) -> None:
+        self._user_custom_attr_value = UserCustomAttrValue()
+
+    def text(self, text: str) -> "UserCustomAttrValueBuilder":
+        self._user_custom_attr_value.text = text
+        return self
+
+    def url(self, url: str) -> "UserCustomAttrValueBuilder":
+        self._user_custom_attr_value.url = url
+        return self
+
+    def pc_url(self, pc_url: str) -> "UserCustomAttrValueBuilder":
+        self._user_custom_attr_value.pc_url = pc_url
+        return self
+
+    def option_id(self, option_id: str) -> "UserCustomAttrValueBuilder":
+        self._user_custom_attr_value.option_id = option_id
+        return self
+
+    def option_value(self, option_value: str) -> "UserCustomAttrValueBuilder":
+        self._user_custom_attr_value.option_value = option_value
+        return self
+
+    def name(self, name: str) -> "UserCustomAttrValueBuilder":
+        self._user_custom_attr_value.name = name
+        return self
+
+    def picture_url(self, picture_url: str) -> "UserCustomAttrValueBuilder":
+        self._user_custom_attr_value.picture_url = picture_url
+        return self
+
+    def generic_user(self, generic_user: CustomAttrGenericUser) -> "UserCustomAttrValueBuilder":
+        self._user_custom_attr_value.generic_user = generic_user
+        return self
+
+    def build(self) -> "UserCustomAttrValue":
+        return self._user_custom_attr_value
diff --git a/lark_channel/api/contact/v3/model/user_department_info.py b/lark_channel/api/contact/v3/model/user_department_info.py
new file mode 100644
index 0000000..5ee472c
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/user_department_info.py
@@ -0,0 +1,40 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class UserDepartmentInfo(object):
+    _types = {
+        "department_id": int,
+        "user_order": int,
+        "department_order": int,
+    }
+
+    def __init__(self, d=None):
+        self.department_id: Optional[int] = None
+        self.user_order: Optional[int] = None
+        self.department_order: Optional[int] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "UserDepartmentInfoBuilder":
+        return UserDepartmentInfoBuilder()
+
+
+class UserDepartmentInfoBuilder(object):
+    def __init__(self) -> None:
+        self._user_department_info = UserDepartmentInfo()
+
+    def department_id(self, department_id: int) -> "UserDepartmentInfoBuilder":
+        self._user_department_info.department_id = department_id
+        return self
+
+    def user_order(self, user_order: int) -> "UserDepartmentInfoBuilder":
+        self._user_department_info.user_order = user_order
+        return self
+
+    def department_order(self, department_order: int) -> "UserDepartmentInfoBuilder":
+        self._user_department_info.department_order = department_order
+        return self
+
+    def build(self) -> "UserDepartmentInfo":
+        return self._user_department_info
diff --git a/lark_channel/api/contact/v3/model/user_order.py b/lark_channel/api/contact/v3/model/user_order.py
new file mode 100644
index 0000000..63cb165
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/user_order.py
@@ -0,0 +1,46 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class UserOrder(object):
+    _types = {
+        "department_id": str,
+        "user_order": int,
+        "department_order": int,
+        "is_primary_dept": bool,
+    }
+
+    def __init__(self, d=None):
+        self.department_id: Optional[str] = None
+        self.user_order: Optional[int] = None
+        self.department_order: Optional[int] = None
+        self.is_primary_dept: Optional[bool] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "UserOrderBuilder":
+        return UserOrderBuilder()
+
+
+class UserOrderBuilder(object):
+    def __init__(self) -> None:
+        self._user_order = UserOrder()
+
+    def department_id(self, department_id: str) -> "UserOrderBuilder":
+        self._user_order.department_id = department_id
+        return self
+
+    def user_order(self, user_order: int) -> "UserOrderBuilder":
+        self._user_order.user_order = user_order
+        return self
+
+    def department_order(self, department_order: int) -> "UserOrderBuilder":
+        self._user_order.department_order = department_order
+        return self
+
+    def is_primary_dept(self, is_primary_dept: bool) -> "UserOrderBuilder":
+        self._user_order.is_primary_dept = is_primary_dept
+        return self
+
+    def build(self) -> "UserOrder":
+        return self._user_order
diff --git a/lark_channel/api/contact/v3/model/user_position.py b/lark_channel/api/contact/v3/model/user_position.py
new file mode 100644
index 0000000..d641b26
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/user_position.py
@@ -0,0 +1,58 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class UserPosition(object):
+    _types = {
+        "position_code": str,
+        "position_name": str,
+        "department_id": str,
+        "leader_user_id": str,
+        "leader_position_code": str,
+        "is_major": bool,
+    }
+
+    def __init__(self, d=None):
+        self.position_code: Optional[str] = None
+        self.position_name: Optional[str] = None
+        self.department_id: Optional[str] = None
+        self.leader_user_id: Optional[str] = None
+        self.leader_position_code: Optional[str] = None
+        self.is_major: Optional[bool] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "UserPositionBuilder":
+        return UserPositionBuilder()
+
+
+class UserPositionBuilder(object):
+    def __init__(self) -> None:
+        self._user_position = UserPosition()
+
+    def position_code(self, position_code: str) -> "UserPositionBuilder":
+        self._user_position.position_code = position_code
+        return self
+
+    def position_name(self, position_name: str) -> "UserPositionBuilder":
+        self._user_position.position_name = position_name
+        return self
+
+    def department_id(self, department_id: str) -> "UserPositionBuilder":
+        self._user_position.department_id = department_id
+        return self
+
+    def leader_user_id(self, leader_user_id: str) -> "UserPositionBuilder":
+        self._user_position.leader_user_id = leader_user_id
+        return self
+
+    def leader_position_code(self, leader_position_code: str) -> "UserPositionBuilder":
+        self._user_position.leader_position_code = leader_position_code
+        return self
+
+    def is_major(self, is_major: bool) -> "UserPositionBuilder":
+        self._user_position.is_major = is_major
+        return self
+
+    def build(self) -> "UserPosition":
+        return self._user_position
diff --git a/lark_channel/api/contact/v3/model/user_status.py b/lark_channel/api/contact/v3/model/user_status.py
new file mode 100644
index 0000000..2bf7f5a
--- /dev/null
+++ b/lark_channel/api/contact/v3/model/user_status.py
@@ -0,0 +1,52 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class UserStatus(object):
+    _types = {
+        "is_frozen": bool,
+        "is_resigned": bool,
+        "is_activated": bool,
+        "is_exited": bool,
+        "is_unjoin": bool,
+    }
+
+    def __init__(self, d=None):
+        self.is_frozen: Optional[bool] = None
+        self.is_resigned: Optional[bool] = None
+        self.is_activated: Optional[bool] = None
+        self.is_exited: Optional[bool] = None
+        self.is_unjoin: Optional[bool] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "UserStatusBuilder":
+        return UserStatusBuilder()
+
+
+class UserStatusBuilder(object):
+    def __init__(self) -> None:
+        self._user_status = UserStatus()
+
+    def is_frozen(self, is_frozen: bool) -> "UserStatusBuilder":
+        self._user_status.is_frozen = is_frozen
+        return self
+
+    def is_resigned(self, is_resigned: bool) -> "UserStatusBuilder":
+        self._user_status.is_resigned = is_resigned
+        return self
+
+    def is_activated(self, is_activated: bool) -> "UserStatusBuilder":
+        self._user_status.is_activated = is_activated
+        return self
+
+    def is_exited(self, is_exited: bool) -> "UserStatusBuilder":
+        self._user_status.is_exited = is_exited
+        return self
+
+    def is_unjoin(self, is_unjoin: bool) -> "UserStatusBuilder":
+        self._user_status.is_unjoin = is_unjoin
+        return self
+
+    def build(self) -> "UserStatus":
+        return self._user_status
diff --git a/lark_channel/api/contact/v3/resource/__init__.py b/lark_channel/api/contact/v3/resource/__init__.py
new file mode 100644
index 0000000..35b01f3
--- /dev/null
+++ b/lark_channel/api/contact/v3/resource/__init__.py
@@ -0,0 +1,3 @@
+from .user import User
+
+__all__ = ["User"]
diff --git a/lark_channel/api/contact/v3/resource/user.py b/lark_channel/api/contact/v3/resource/user.py
new file mode 100644
index 0000000..b9b2cce
--- /dev/null
+++ b/lark_channel/api/contact/v3/resource/user.py
@@ -0,0 +1,439 @@
+import io
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.const import UTF_8, CONTENT_TYPE, APPLICATION_JSON
+from lark_channel.core import JSON
+from lark_channel.core.token import verify
+from lark_channel.core.http import Transport
+from lark_channel.core.model import Config, RequestOption, RawResponse
+from lark_channel.core.utils import Files
+from requests_toolbelt import MultipartEncoder
+from ..model.batch_user_request import BatchUserRequest
+from ..model.batch_user_response import BatchUserResponse
+from ..model.batch_get_id_user_request import BatchGetIdUserRequest
+from ..model.batch_get_id_user_response import BatchGetIdUserResponse
+from ..model.create_user_request import CreateUserRequest
+from ..model.create_user_response import CreateUserResponse
+from ..model.delete_user_request import DeleteUserRequest
+from ..model.delete_user_response import DeleteUserResponse
+from ..model.find_by_department_user_request import FindByDepartmentUserRequest
+from ..model.find_by_department_user_response import FindByDepartmentUserResponse
+from ..model.get_user_request import GetUserRequest
+from ..model.get_user_response import GetUserResponse
+from ..model.list_user_request import ListUserRequest
+from ..model.list_user_response import ListUserResponse
+from ..model.patch_user_request import PatchUserRequest
+from ..model.patch_user_response import PatchUserResponse
+from ..model.resurrect_user_request import ResurrectUserRequest
+from ..model.resurrect_user_response import ResurrectUserResponse
+from ..model.update_user_request import UpdateUserRequest
+from ..model.update_user_response import UpdateUserResponse
+from ..model.update_user_id_user_request import UpdateUserIdUserRequest
+from ..model.update_user_id_user_response import UpdateUserIdUserResponse
+
+
+class User(object):
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+
+    def batch(self, request: BatchUserRequest, option: Optional[RequestOption] = None) -> BatchUserResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: BatchUserResponse = JSON.unmarshal(str(resp.content, UTF_8), BatchUserResponse)
+        response.raw = resp
+
+        return response
+
+    async def abatch(self, request: BatchUserRequest, option: Optional[RequestOption] = None) -> BatchUserResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: BatchUserResponse = JSON.unmarshal(str(resp.content, UTF_8), BatchUserResponse)
+        response.raw = resp
+
+        return response
+
+    def batch_get_id(self, request: BatchGetIdUserRequest,
+                     option: Optional[RequestOption] = None) -> BatchGetIdUserResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: BatchGetIdUserResponse = JSON.unmarshal(str(resp.content, UTF_8), BatchGetIdUserResponse)
+        response.raw = resp
+
+        return response
+
+    async def abatch_get_id(self, request: BatchGetIdUserRequest,
+                            option: Optional[RequestOption] = None) -> BatchGetIdUserResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: BatchGetIdUserResponse = JSON.unmarshal(str(resp.content, UTF_8), BatchGetIdUserResponse)
+        response.raw = resp
+
+        return response
+
+    def create(self, request: CreateUserRequest, option: Optional[RequestOption] = None) -> CreateUserResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: CreateUserResponse = JSON.unmarshal(str(resp.content, UTF_8), CreateUserResponse)
+        response.raw = resp
+
+        return response
+
+    async def acreate(self, request: CreateUserRequest, option: Optional[RequestOption] = None) -> CreateUserResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: CreateUserResponse = JSON.unmarshal(str(resp.content, UTF_8), CreateUserResponse)
+        response.raw = resp
+
+        return response
+
+    def delete(self, request: DeleteUserRequest, option: Optional[RequestOption] = None) -> DeleteUserResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: DeleteUserResponse = JSON.unmarshal(str(resp.content, UTF_8), DeleteUserResponse)
+        response.raw = resp
+
+        return response
+
+    async def adelete(self, request: DeleteUserRequest, option: Optional[RequestOption] = None) -> DeleteUserResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: DeleteUserResponse = JSON.unmarshal(str(resp.content, UTF_8), DeleteUserResponse)
+        response.raw = resp
+
+        return response
+
+    def find_by_department(self, request: FindByDepartmentUserRequest,
+                           option: Optional[RequestOption] = None) -> FindByDepartmentUserResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: FindByDepartmentUserResponse = JSON.unmarshal(str(resp.content, UTF_8), FindByDepartmentUserResponse)
+        response.raw = resp
+
+        return response
+
+    async def afind_by_department(self, request: FindByDepartmentUserRequest,
+                                  option: Optional[RequestOption] = None) -> FindByDepartmentUserResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: FindByDepartmentUserResponse = JSON.unmarshal(str(resp.content, UTF_8), FindByDepartmentUserResponse)
+        response.raw = resp
+
+        return response
+
+    def get(self, request: GetUserRequest, option: Optional[RequestOption] = None) -> GetUserResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: GetUserResponse = JSON.unmarshal(str(resp.content, UTF_8), GetUserResponse)
+        response.raw = resp
+
+        return response
+
+    async def aget(self, request: GetUserRequest, option: Optional[RequestOption] = None) -> GetUserResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: GetUserResponse = JSON.unmarshal(str(resp.content, UTF_8), GetUserResponse)
+        response.raw = resp
+
+        return response
+
+    def list(self, request: ListUserRequest, option: Optional[RequestOption] = None) -> ListUserResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: ListUserResponse = JSON.unmarshal(str(resp.content, UTF_8), ListUserResponse)
+        response.raw = resp
+
+        return response
+
+    async def alist(self, request: ListUserRequest, option: Optional[RequestOption] = None) -> ListUserResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: ListUserResponse = JSON.unmarshal(str(resp.content, UTF_8), ListUserResponse)
+        response.raw = resp
+
+        return response
+
+    def patch(self, request: PatchUserRequest, option: Optional[RequestOption] = None) -> PatchUserResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: PatchUserResponse = JSON.unmarshal(str(resp.content, UTF_8), PatchUserResponse)
+        response.raw = resp
+
+        return response
+
+    async def apatch(self, request: PatchUserRequest, option: Optional[RequestOption] = None) -> PatchUserResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: PatchUserResponse = JSON.unmarshal(str(resp.content, UTF_8), PatchUserResponse)
+        response.raw = resp
+
+        return response
+
+    def resurrect(self, request: ResurrectUserRequest, option: Optional[RequestOption] = None) -> ResurrectUserResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: ResurrectUserResponse = JSON.unmarshal(str(resp.content, UTF_8), ResurrectUserResponse)
+        response.raw = resp
+
+        return response
+
+    async def aresurrect(self, request: ResurrectUserRequest,
+                         option: Optional[RequestOption] = None) -> ResurrectUserResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: ResurrectUserResponse = JSON.unmarshal(str(resp.content, UTF_8), ResurrectUserResponse)
+        response.raw = resp
+
+        return response
+
+    def update(self, request: UpdateUserRequest, option: Optional[RequestOption] = None) -> UpdateUserResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: UpdateUserResponse = JSON.unmarshal(str(resp.content, UTF_8), UpdateUserResponse)
+        response.raw = resp
+
+        return response
+
+    async def aupdate(self, request: UpdateUserRequest, option: Optional[RequestOption] = None) -> UpdateUserResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: UpdateUserResponse = JSON.unmarshal(str(resp.content, UTF_8), UpdateUserResponse)
+        response.raw = resp
+
+        return response
+
+    def update_user_id(self, request: UpdateUserIdUserRequest,
+                       option: Optional[RequestOption] = None) -> UpdateUserIdUserResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: UpdateUserIdUserResponse = JSON.unmarshal(str(resp.content, UTF_8), UpdateUserIdUserResponse)
+        response.raw = resp
+
+        return response
+
+    async def aupdate_user_id(self, request: UpdateUserIdUserRequest,
+                              option: Optional[RequestOption] = None) -> UpdateUserIdUserResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: UpdateUserIdUserResponse = JSON.unmarshal(str(resp.content, UTF_8), UpdateUserIdUserResponse)
+        response.raw = resp
+
+        return response
diff --git a/lark_channel/api/contact/v3/version.py b/lark_channel/api/contact/v3/version.py
new file mode 100644
index 0000000..7d5e667
--- /dev/null
+++ b/lark_channel/api/contact/v3/version.py
@@ -0,0 +1,8 @@
+from lark_channel.core.model import Config
+
+from .resource import User
+
+
+class V3(object):
+    def __init__(self, config: Config) -> None:
+        self.user: User = User(config)
diff --git a/lark_channel/api/drive/__init__.py b/lark_channel/api/drive/__init__.py
new file mode 100644
index 0000000..0b12163
--- /dev/null
+++ b/lark_channel/api/drive/__init__.py
@@ -0,0 +1 @@
+"""Minimal Drive primitives required by lark_channel."""
diff --git a/lark_channel/api/drive/comment.py b/lark_channel/api/drive/comment.py
new file mode 100644
index 0000000..eb027ac
--- /dev/null
+++ b/lark_channel/api/drive/comment.py
@@ -0,0 +1,97 @@
+from lark_channel.core.enum import AccessTokenType, HttpMethod
+from lark_channel.core.model import BaseRequest
+
+
+def _request(method: HttpMethod, uri: str) -> BaseRequest:
+    req = BaseRequest()
+    req.http_method = method
+    req.uri = uri
+    req.token_types = {AccessTokenType.TENANT, AccessTokenType.USER}
+    return req
+
+
+def _reply_content(content: str):
+    return {
+        "elements": [
+            {
+                "type": "text_run",
+                "text_run": {"text": content},
+            }
+        ],
+    }
+
+
+def build_comment_get_request(*, file_token: str, file_type: str, comment_id: str) -> BaseRequest:
+    req = _request(HttpMethod.GET, "/open-apis/drive/v1/files/:file_token/comments/:comment_id")
+    req.paths["file_token"] = file_token
+    req.paths["comment_id"] = comment_id
+    req.add_query("file_type", file_type)
+    return req
+
+
+def build_comment_list_request(
+    *,
+    file_token: str,
+    file_type: str,
+    page_token=None,
+    page_size=None,
+    is_whole=None,
+    is_solved=None,
+) -> BaseRequest:
+    req = _request(HttpMethod.GET, "/open-apis/drive/v1/files/:file_token/comments")
+    req.paths["file_token"] = file_token
+    req.add_query("file_type", file_type)
+    if page_token is not None:
+        req.add_query("page_token", page_token)
+    if page_size is not None:
+        req.add_query("page_size", page_size)
+    if is_whole is not None:
+        req.add_query("is_whole", is_whole)
+    if is_solved is not None:
+        req.add_query("is_solved", is_solved)
+    return req
+
+
+def build_comment_reply_list_request(
+    *,
+    file_token: str,
+    file_type: str,
+    comment_id: str,
+    page_token=None,
+    page_size=None,
+) -> BaseRequest:
+    req = _request(
+        HttpMethod.GET,
+        "/open-apis/drive/v1/files/:file_token/comments/:comment_id/replies",
+    )
+    req.paths["file_token"] = file_token
+    req.paths["comment_id"] = comment_id
+    req.add_query("file_type", file_type)
+    if page_token is not None:
+        req.add_query("page_token", page_token)
+    if page_size is not None:
+        req.add_query("page_size", page_size)
+    return req
+
+
+def build_comment_create_request(*, file_token: str, file_type: str, content: str) -> BaseRequest:
+    req = _request(HttpMethod.POST, "/open-apis/drive/v1/files/:file_token/comments")
+    req.paths["file_token"] = file_token
+    req.add_query("file_type", file_type)
+    req.body = {"reply_list": {"replies": [{"content": _reply_content(content)}]}}
+    return req
+
+
+def build_comment_reply_update_request(
+    *, file_token: str, file_type: str, comment_id: str, reply_id: str, content: str
+) -> BaseRequest:
+    req = _request(
+        HttpMethod.PUT,
+        "/open-apis/drive/v1/files/:file_token/comments/:comment_id/replies/:reply_id",
+    )
+    req.paths["file_token"] = file_token
+    req.paths["comment_id"] = comment_id
+    req.paths["reply_id"] = reply_id
+    req.add_query("file_type", file_type)
+    req.body = {"content": _reply_content(content)}
+    return req
diff --git a/lark_channel/api/im/__init__.py b/lark_channel/api/im/__init__.py
new file mode 100644
index 0000000..326cdf4
--- /dev/null
+++ b/lark_channel/api/im/__init__.py
@@ -0,0 +1 @@
+from . import v1
diff --git a/lark_channel/api/im/service.py b/lark_channel/api/im/service.py
new file mode 100644
index 0000000..a90adc4
--- /dev/null
+++ b/lark_channel/api/im/service.py
@@ -0,0 +1,7 @@
+from .v1.version import V1
+from lark_channel.core.model import Config
+
+
+class ImService(object):
+    def __init__(self, config: Config) -> None:
+        self.v1: V1 = V1(config)
diff --git a/lark_channel/api/im/v1/__init__.py b/lark_channel/api/im/v1/__init__.py
new file mode 100644
index 0000000..bced8e1
--- /dev/null
+++ b/lark_channel/api/im/v1/__init__.py
@@ -0,0 +1,5 @@
+"""Minimal IM v1 resources required by lark_channel."""
+
+from .version import V1
+
+__all__ = ["V1"]
diff --git a/lark_channel/api/im/v1/model/__init__.py b/lark_channel/api/im/v1/model/__init__.py
new file mode 100644
index 0000000..e65733f
--- /dev/null
+++ b/lark_channel/api/im/v1/model/__init__.py
@@ -0,0 +1 @@
+"""IM model submodules are imported explicitly by lark_channel."""
diff --git a/lark_channel/api/im/v1/model/chat_change.py b/lark_channel/api/im/v1/model/chat_change.py
new file mode 100644
index 0000000..965fa60
--- /dev/null
+++ b/lark_channel/api/im/v1/model/chat_change.py
@@ -0,0 +1,121 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .i18n_names import I18nNames
+from .user_id import UserId
+from .restricted_mode_setting import RestrictedModeSetting
+
+
+class ChatChange(object):
+    _types = {
+        "avatar": str,
+        "name": str,
+        "description": str,
+        "i18n_names": I18nNames,
+        "add_member_permission": str,
+        "share_card_permission": str,
+        "at_all_permission": str,
+        "edit_permission": str,
+        "membership_approval": str,
+        "join_message_visibility": str,
+        "leave_message_visibility": str,
+        "moderation_permission": str,
+        "owner_id": UserId,
+        "labels": List[str],
+        "restricted_mode_setting": RestrictedModeSetting,
+        "group_message_type": str,
+    }
+
+    def __init__(self, d=None):
+        self.avatar: Optional[str] = None
+        self.name: Optional[str] = None
+        self.description: Optional[str] = None
+        self.i18n_names: Optional[I18nNames] = None
+        self.add_member_permission: Optional[str] = None
+        self.share_card_permission: Optional[str] = None
+        self.at_all_permission: Optional[str] = None
+        self.edit_permission: Optional[str] = None
+        self.membership_approval: Optional[str] = None
+        self.join_message_visibility: Optional[str] = None
+        self.leave_message_visibility: Optional[str] = None
+        self.moderation_permission: Optional[str] = None
+        self.owner_id: Optional[UserId] = None
+        self.labels: Optional[List[str]] = None
+        self.restricted_mode_setting: Optional[RestrictedModeSetting] = None
+        self.group_message_type: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "ChatChangeBuilder":
+        return ChatChangeBuilder()
+
+
+class ChatChangeBuilder(object):
+    def __init__(self) -> None:
+        self._chat_change = ChatChange()
+
+    def avatar(self, avatar: str) -> "ChatChangeBuilder":
+        self._chat_change.avatar = avatar
+        return self
+
+    def name(self, name: str) -> "ChatChangeBuilder":
+        self._chat_change.name = name
+        return self
+
+    def description(self, description: str) -> "ChatChangeBuilder":
+        self._chat_change.description = description
+        return self
+
+    def i18n_names(self, i18n_names: I18nNames) -> "ChatChangeBuilder":
+        self._chat_change.i18n_names = i18n_names
+        return self
+
+    def add_member_permission(self, add_member_permission: str) -> "ChatChangeBuilder":
+        self._chat_change.add_member_permission = add_member_permission
+        return self
+
+    def share_card_permission(self, share_card_permission: str) -> "ChatChangeBuilder":
+        self._chat_change.share_card_permission = share_card_permission
+        return self
+
+    def at_all_permission(self, at_all_permission: str) -> "ChatChangeBuilder":
+        self._chat_change.at_all_permission = at_all_permission
+        return self
+
+    def edit_permission(self, edit_permission: str) -> "ChatChangeBuilder":
+        self._chat_change.edit_permission = edit_permission
+        return self
+
+    def membership_approval(self, membership_approval: str) -> "ChatChangeBuilder":
+        self._chat_change.membership_approval = membership_approval
+        return self
+
+    def join_message_visibility(self, join_message_visibility: str) -> "ChatChangeBuilder":
+        self._chat_change.join_message_visibility = join_message_visibility
+        return self
+
+    def leave_message_visibility(self, leave_message_visibility: str) -> "ChatChangeBuilder":
+        self._chat_change.leave_message_visibility = leave_message_visibility
+        return self
+
+    def moderation_permission(self, moderation_permission: str) -> "ChatChangeBuilder":
+        self._chat_change.moderation_permission = moderation_permission
+        return self
+
+    def owner_id(self, owner_id: UserId) -> "ChatChangeBuilder":
+        self._chat_change.owner_id = owner_id
+        return self
+
+    def labels(self, labels: List[str]) -> "ChatChangeBuilder":
+        self._chat_change.labels = labels
+        return self
+
+    def restricted_mode_setting(self, restricted_mode_setting: RestrictedModeSetting) -> "ChatChangeBuilder":
+        self._chat_change.restricted_mode_setting = restricted_mode_setting
+        return self
+
+    def group_message_type(self, group_message_type: str) -> "ChatChangeBuilder":
+        self._chat_change.group_message_type = group_message_type
+        return self
+
+    def build(self) -> "ChatChange":
+        return self._chat_change
diff --git a/lark_channel/api/im/v1/model/chat_member_user.py b/lark_channel/api/im/v1/model/chat_member_user.py
new file mode 100644
index 0000000..83e4c2e
--- /dev/null
+++ b/lark_channel/api/im/v1/model/chat_member_user.py
@@ -0,0 +1,41 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .user_id import UserId
+
+
+class ChatMemberUser(object):
+    _types = {
+        "name": str,
+        "tenant_key": str,
+        "user_id": UserId,
+    }
+
+    def __init__(self, d=None):
+        self.name: Optional[str] = None
+        self.tenant_key: Optional[str] = None
+        self.user_id: Optional[UserId] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "ChatMemberUserBuilder":
+        return ChatMemberUserBuilder()
+
+
+class ChatMemberUserBuilder(object):
+    def __init__(self) -> None:
+        self._chat_member_user = ChatMemberUser()
+
+    def name(self, name: str) -> "ChatMemberUserBuilder":
+        self._chat_member_user.name = name
+        return self
+
+    def tenant_key(self, tenant_key: str) -> "ChatMemberUserBuilder":
+        self._chat_member_user.tenant_key = tenant_key
+        return self
+
+    def user_id(self, user_id: UserId) -> "ChatMemberUserBuilder":
+        self._chat_member_user.user_id = user_id
+        return self
+
+    def build(self) -> "ChatMemberUser":
+        return self._chat_member_user
diff --git a/lark_channel/api/im/v1/model/create_chat_request.py b/lark_channel/api/im/v1/model/create_chat_request.py
new file mode 100644
index 0000000..eba1368
--- /dev/null
+++ b/lark_channel/api/im/v1/model/create_chat_request.py
@@ -0,0 +1,50 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .create_chat_request_body import CreateChatRequestBody
+
+
+class CreateChatRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.user_id_type: Optional[str] = None
+        self.set_bot_manager: Optional[bool] = None
+        self.uuid: Optional[str] = None
+        self.request_body: Optional[CreateChatRequestBody] = None
+
+    @staticmethod
+    def builder() -> "CreateChatRequestBuilder":
+        return CreateChatRequestBuilder()
+
+
+class CreateChatRequestBuilder(object):
+
+    def __init__(self) -> None:
+        create_chat_request = CreateChatRequest()
+        create_chat_request.http_method = HttpMethod.POST
+        create_chat_request.uri = "/open-apis/im/v1/chats"
+        create_chat_request.token_types = {AccessTokenType.TENANT}
+        self._create_chat_request: CreateChatRequest = create_chat_request
+
+    def user_id_type(self, user_id_type: str) -> "CreateChatRequestBuilder":
+        self._create_chat_request.user_id_type = user_id_type
+        self._create_chat_request.add_query("user_id_type", user_id_type)
+        return self
+
+    def set_bot_manager(self, set_bot_manager: bool) -> "CreateChatRequestBuilder":
+        self._create_chat_request.set_bot_manager = set_bot_manager
+        self._create_chat_request.add_query("set_bot_manager", set_bot_manager)
+        return self
+
+    def uuid(self, uuid: str) -> "CreateChatRequestBuilder":
+        self._create_chat_request.uuid = uuid
+        self._create_chat_request.add_query("uuid", uuid)
+        return self
+
+    def request_body(self, request_body: CreateChatRequestBody) -> "CreateChatRequestBuilder":
+        self._create_chat_request.request_body = request_body
+        self._create_chat_request.body = request_body
+        return self
+
+    def build(self) -> CreateChatRequest:
+        return self._create_chat_request
diff --git a/lark_channel/api/im/v1/model/create_chat_request_body.py b/lark_channel/api/im/v1/model/create_chat_request_body.py
new file mode 100644
index 0000000..f55fe7e
--- /dev/null
+++ b/lark_channel/api/im/v1/model/create_chat_request_body.py
@@ -0,0 +1,162 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .i18n_names import I18nNames
+from .restricted_mode_setting import RestrictedModeSetting
+
+
+class CreateChatRequestBody(object):
+    _types = {
+        "avatar": str,
+        "name": str,
+        "description": str,
+        "i18n_names": I18nNames,
+        "owner_id": str,
+        "user_id_list": List[str],
+        "bot_id_list": List[str],
+        "group_message_type": str,
+        "chat_mode": str,
+        "chat_type": str,
+        "external": bool,
+        "join_message_visibility": str,
+        "leave_message_visibility": str,
+        "membership_approval": str,
+        "labels": List[str],
+        "toolkit_ids": List[int],
+        "restricted_mode_setting": RestrictedModeSetting,
+        "urgent_setting": str,
+        "video_conference_setting": str,
+        "edit_permission": str,
+        "chat_tags": List[str],
+        "pin_manage_setting": str,
+        "hide_member_count_setting": str,
+    }
+
+    def __init__(self, d=None):
+        self.avatar: Optional[str] = None
+        self.name: Optional[str] = None
+        self.description: Optional[str] = None
+        self.i18n_names: Optional[I18nNames] = None
+        self.owner_id: Optional[str] = None
+        self.user_id_list: Optional[List[str]] = None
+        self.bot_id_list: Optional[List[str]] = None
+        self.group_message_type: Optional[str] = None
+        self.chat_mode: Optional[str] = None
+        self.chat_type: Optional[str] = None
+        self.external: Optional[bool] = None
+        self.join_message_visibility: Optional[str] = None
+        self.leave_message_visibility: Optional[str] = None
+        self.membership_approval: Optional[str] = None
+        self.labels: Optional[List[str]] = None
+        self.toolkit_ids: Optional[List[int]] = None
+        self.restricted_mode_setting: Optional[RestrictedModeSetting] = None
+        self.urgent_setting: Optional[str] = None
+        self.video_conference_setting: Optional[str] = None
+        self.edit_permission: Optional[str] = None
+        self.chat_tags: Optional[List[str]] = None
+        self.pin_manage_setting: Optional[str] = None
+        self.hide_member_count_setting: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "CreateChatRequestBodyBuilder":
+        return CreateChatRequestBodyBuilder()
+
+
+class CreateChatRequestBodyBuilder(object):
+    def __init__(self) -> None:
+        self._create_chat_request_body = CreateChatRequestBody()
+
+    def avatar(self, avatar: str) -> "CreateChatRequestBodyBuilder":
+        self._create_chat_request_body.avatar = avatar
+        return self
+
+    def name(self, name: str) -> "CreateChatRequestBodyBuilder":
+        self._create_chat_request_body.name = name
+        return self
+
+    def description(self, description: str) -> "CreateChatRequestBodyBuilder":
+        self._create_chat_request_body.description = description
+        return self
+
+    def i18n_names(self, i18n_names: I18nNames) -> "CreateChatRequestBodyBuilder":
+        self._create_chat_request_body.i18n_names = i18n_names
+        return self
+
+    def owner_id(self, owner_id: str) -> "CreateChatRequestBodyBuilder":
+        self._create_chat_request_body.owner_id = owner_id
+        return self
+
+    def user_id_list(self, user_id_list: List[str]) -> "CreateChatRequestBodyBuilder":
+        self._create_chat_request_body.user_id_list = user_id_list
+        return self
+
+    def bot_id_list(self, bot_id_list: List[str]) -> "CreateChatRequestBodyBuilder":
+        self._create_chat_request_body.bot_id_list = bot_id_list
+        return self
+
+    def group_message_type(self, group_message_type: str) -> "CreateChatRequestBodyBuilder":
+        self._create_chat_request_body.group_message_type = group_message_type
+        return self
+
+    def chat_mode(self, chat_mode: str) -> "CreateChatRequestBodyBuilder":
+        self._create_chat_request_body.chat_mode = chat_mode
+        return self
+
+    def chat_type(self, chat_type: str) -> "CreateChatRequestBodyBuilder":
+        self._create_chat_request_body.chat_type = chat_type
+        return self
+
+    def external(self, external: bool) -> "CreateChatRequestBodyBuilder":
+        self._create_chat_request_body.external = external
+        return self
+
+    def join_message_visibility(self, join_message_visibility: str) -> "CreateChatRequestBodyBuilder":
+        self._create_chat_request_body.join_message_visibility = join_message_visibility
+        return self
+
+    def leave_message_visibility(self, leave_message_visibility: str) -> "CreateChatRequestBodyBuilder":
+        self._create_chat_request_body.leave_message_visibility = leave_message_visibility
+        return self
+
+    def membership_approval(self, membership_approval: str) -> "CreateChatRequestBodyBuilder":
+        self._create_chat_request_body.membership_approval = membership_approval
+        return self
+
+    def labels(self, labels: List[str]) -> "CreateChatRequestBodyBuilder":
+        self._create_chat_request_body.labels = labels
+        return self
+
+    def toolkit_ids(self, toolkit_ids: List[int]) -> "CreateChatRequestBodyBuilder":
+        self._create_chat_request_body.toolkit_ids = toolkit_ids
+        return self
+
+    def restricted_mode_setting(self, restricted_mode_setting: RestrictedModeSetting) -> "CreateChatRequestBodyBuilder":
+        self._create_chat_request_body.restricted_mode_setting = restricted_mode_setting
+        return self
+
+    def urgent_setting(self, urgent_setting: str) -> "CreateChatRequestBodyBuilder":
+        self._create_chat_request_body.urgent_setting = urgent_setting
+        return self
+
+    def video_conference_setting(self, video_conference_setting: str) -> "CreateChatRequestBodyBuilder":
+        self._create_chat_request_body.video_conference_setting = video_conference_setting
+        return self
+
+    def edit_permission(self, edit_permission: str) -> "CreateChatRequestBodyBuilder":
+        self._create_chat_request_body.edit_permission = edit_permission
+        return self
+
+    def chat_tags(self, chat_tags: List[str]) -> "CreateChatRequestBodyBuilder":
+        self._create_chat_request_body.chat_tags = chat_tags
+        return self
+
+    def pin_manage_setting(self, pin_manage_setting: str) -> "CreateChatRequestBodyBuilder":
+        self._create_chat_request_body.pin_manage_setting = pin_manage_setting
+        return self
+
+    def hide_member_count_setting(self, hide_member_count_setting: str) -> "CreateChatRequestBodyBuilder":
+        self._create_chat_request_body.hide_member_count_setting = hide_member_count_setting
+        return self
+
+    def build(self) -> "CreateChatRequestBody":
+        return self._create_chat_request_body
diff --git a/lark_channel/api/im/v1/model/create_chat_response.py b/lark_channel/api/im/v1/model/create_chat_response.py
new file mode 100644
index 0000000..7bc8411
--- /dev/null
+++ b/lark_channel/api/im/v1/model/create_chat_response.py
@@ -0,0 +1,15 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+from .create_chat_response_body import CreateChatResponseBody
+
+
+class CreateChatResponse(BaseResponse):
+    _types = {
+        "data": CreateChatResponseBody
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.data: Optional[CreateChatResponseBody] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/create_chat_response_body.py b/lark_channel/api/im/v1/model/create_chat_response_body.py
new file mode 100644
index 0000000..42be20d
--- /dev/null
+++ b/lark_channel/api/im/v1/model/create_chat_response_body.py
@@ -0,0 +1,193 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .i18n_names import I18nNames
+from .restricted_mode_setting import RestrictedModeSetting
+
+
+class CreateChatResponseBody(object):
+    _types = {
+        "chat_id": str,
+        "avatar": str,
+        "name": str,
+        "description": str,
+        "i18n_names": I18nNames,
+        "owner_id": str,
+        "owner_id_type": str,
+        "urgent_setting": str,
+        "video_conference_setting": str,
+        "pin_manage_setting": str,
+        "add_member_permission": str,
+        "share_card_permission": str,
+        "at_all_permission": str,
+        "edit_permission": str,
+        "group_message_type": str,
+        "chat_mode": str,
+        "chat_type": str,
+        "chat_tag": str,
+        "external": bool,
+        "tenant_key": str,
+        "join_message_visibility": str,
+        "leave_message_visibility": str,
+        "membership_approval": str,
+        "moderation_permission": str,
+        "labels": List[str],
+        "toolkit_ids": List[int],
+        "restricted_mode_setting": RestrictedModeSetting,
+        "hide_member_count_setting": str,
+    }
+
+    def __init__(self, d=None):
+        self.chat_id: Optional[str] = None
+        self.avatar: Optional[str] = None
+        self.name: Optional[str] = None
+        self.description: Optional[str] = None
+        self.i18n_names: Optional[I18nNames] = None
+        self.owner_id: Optional[str] = None
+        self.owner_id_type: Optional[str] = None
+        self.urgent_setting: Optional[str] = None
+        self.video_conference_setting: Optional[str] = None
+        self.pin_manage_setting: Optional[str] = None
+        self.add_member_permission: Optional[str] = None
+        self.share_card_permission: Optional[str] = None
+        self.at_all_permission: Optional[str] = None
+        self.edit_permission: Optional[str] = None
+        self.group_message_type: Optional[str] = None
+        self.chat_mode: Optional[str] = None
+        self.chat_type: Optional[str] = None
+        self.chat_tag: Optional[str] = None
+        self.external: Optional[bool] = None
+        self.tenant_key: Optional[str] = None
+        self.join_message_visibility: Optional[str] = None
+        self.leave_message_visibility: Optional[str] = None
+        self.membership_approval: Optional[str] = None
+        self.moderation_permission: Optional[str] = None
+        self.labels: Optional[List[str]] = None
+        self.toolkit_ids: Optional[List[int]] = None
+        self.restricted_mode_setting: Optional[RestrictedModeSetting] = None
+        self.hide_member_count_setting: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "CreateChatResponseBodyBuilder":
+        return CreateChatResponseBodyBuilder()
+
+
+class CreateChatResponseBodyBuilder(object):
+    def __init__(self) -> None:
+        self._create_chat_response_body = CreateChatResponseBody()
+
+    def chat_id(self, chat_id: str) -> "CreateChatResponseBodyBuilder":
+        self._create_chat_response_body.chat_id = chat_id
+        return self
+
+    def avatar(self, avatar: str) -> "CreateChatResponseBodyBuilder":
+        self._create_chat_response_body.avatar = avatar
+        return self
+
+    def name(self, name: str) -> "CreateChatResponseBodyBuilder":
+        self._create_chat_response_body.name = name
+        return self
+
+    def description(self, description: str) -> "CreateChatResponseBodyBuilder":
+        self._create_chat_response_body.description = description
+        return self
+
+    def i18n_names(self, i18n_names: I18nNames) -> "CreateChatResponseBodyBuilder":
+        self._create_chat_response_body.i18n_names = i18n_names
+        return self
+
+    def owner_id(self, owner_id: str) -> "CreateChatResponseBodyBuilder":
+        self._create_chat_response_body.owner_id = owner_id
+        return self
+
+    def owner_id_type(self, owner_id_type: str) -> "CreateChatResponseBodyBuilder":
+        self._create_chat_response_body.owner_id_type = owner_id_type
+        return self
+
+    def urgent_setting(self, urgent_setting: str) -> "CreateChatResponseBodyBuilder":
+        self._create_chat_response_body.urgent_setting = urgent_setting
+        return self
+
+    def video_conference_setting(self, video_conference_setting: str) -> "CreateChatResponseBodyBuilder":
+        self._create_chat_response_body.video_conference_setting = video_conference_setting
+        return self
+
+    def pin_manage_setting(self, pin_manage_setting: str) -> "CreateChatResponseBodyBuilder":
+        self._create_chat_response_body.pin_manage_setting = pin_manage_setting
+        return self
+
+    def add_member_permission(self, add_member_permission: str) -> "CreateChatResponseBodyBuilder":
+        self._create_chat_response_body.add_member_permission = add_member_permission
+        return self
+
+    def share_card_permission(self, share_card_permission: str) -> "CreateChatResponseBodyBuilder":
+        self._create_chat_response_body.share_card_permission = share_card_permission
+        return self
+
+    def at_all_permission(self, at_all_permission: str) -> "CreateChatResponseBodyBuilder":
+        self._create_chat_response_body.at_all_permission = at_all_permission
+        return self
+
+    def edit_permission(self, edit_permission: str) -> "CreateChatResponseBodyBuilder":
+        self._create_chat_response_body.edit_permission = edit_permission
+        return self
+
+    def group_message_type(self, group_message_type: str) -> "CreateChatResponseBodyBuilder":
+        self._create_chat_response_body.group_message_type = group_message_type
+        return self
+
+    def chat_mode(self, chat_mode: str) -> "CreateChatResponseBodyBuilder":
+        self._create_chat_response_body.chat_mode = chat_mode
+        return self
+
+    def chat_type(self, chat_type: str) -> "CreateChatResponseBodyBuilder":
+        self._create_chat_response_body.chat_type = chat_type
+        return self
+
+    def chat_tag(self, chat_tag: str) -> "CreateChatResponseBodyBuilder":
+        self._create_chat_response_body.chat_tag = chat_tag
+        return self
+
+    def external(self, external: bool) -> "CreateChatResponseBodyBuilder":
+        self._create_chat_response_body.external = external
+        return self
+
+    def tenant_key(self, tenant_key: str) -> "CreateChatResponseBodyBuilder":
+        self._create_chat_response_body.tenant_key = tenant_key
+        return self
+
+    def join_message_visibility(self, join_message_visibility: str) -> "CreateChatResponseBodyBuilder":
+        self._create_chat_response_body.join_message_visibility = join_message_visibility
+        return self
+
+    def leave_message_visibility(self, leave_message_visibility: str) -> "CreateChatResponseBodyBuilder":
+        self._create_chat_response_body.leave_message_visibility = leave_message_visibility
+        return self
+
+    def membership_approval(self, membership_approval: str) -> "CreateChatResponseBodyBuilder":
+        self._create_chat_response_body.membership_approval = membership_approval
+        return self
+
+    def moderation_permission(self, moderation_permission: str) -> "CreateChatResponseBodyBuilder":
+        self._create_chat_response_body.moderation_permission = moderation_permission
+        return self
+
+    def labels(self, labels: List[str]) -> "CreateChatResponseBodyBuilder":
+        self._create_chat_response_body.labels = labels
+        return self
+
+    def toolkit_ids(self, toolkit_ids: List[int]) -> "CreateChatResponseBodyBuilder":
+        self._create_chat_response_body.toolkit_ids = toolkit_ids
+        return self
+
+    def restricted_mode_setting(self,
+                                restricted_mode_setting: RestrictedModeSetting) -> "CreateChatResponseBodyBuilder":
+        self._create_chat_response_body.restricted_mode_setting = restricted_mode_setting
+        return self
+
+    def hide_member_count_setting(self, hide_member_count_setting: str) -> "CreateChatResponseBodyBuilder":
+        self._create_chat_response_body.hide_member_count_setting = hide_member_count_setting
+        return self
+
+    def build(self) -> "CreateChatResponseBody":
+        return self._create_chat_response_body
diff --git a/lark_channel/api/im/v1/model/create_file_request.py b/lark_channel/api/im/v1/model/create_file_request.py
new file mode 100644
index 0000000..aa82ff8
--- /dev/null
+++ b/lark_channel/api/im/v1/model/create_file_request.py
@@ -0,0 +1,32 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .create_file_request_body import CreateFileRequestBody
+
+
+class CreateFileRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.request_body: Optional[CreateFileRequestBody] = None
+
+    @staticmethod
+    def builder() -> "CreateFileRequestBuilder":
+        return CreateFileRequestBuilder()
+
+
+class CreateFileRequestBuilder(object):
+
+    def __init__(self) -> None:
+        create_file_request = CreateFileRequest()
+        create_file_request.http_method = HttpMethod.POST
+        create_file_request.uri = "/open-apis/im/v1/files"
+        create_file_request.token_types = {AccessTokenType.TENANT}
+        self._create_file_request: CreateFileRequest = create_file_request
+
+    def request_body(self, request_body: CreateFileRequestBody) -> "CreateFileRequestBuilder":
+        self._create_file_request.request_body = request_body
+        self._create_file_request.body = request_body
+        return self
+
+    def build(self) -> CreateFileRequest:
+        return self._create_file_request
diff --git a/lark_channel/api/im/v1/model/create_file_request_body.py b/lark_channel/api/im/v1/model/create_file_request_body.py
new file mode 100644
index 0000000..776a46f
--- /dev/null
+++ b/lark_channel/api/im/v1/model/create_file_request_body.py
@@ -0,0 +1,46 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class CreateFileRequestBody(object):
+    _types = {
+        "file_type": str,
+        "file_name": str,
+        "duration": int,
+        "file": IO[Any],
+    }
+
+    def __init__(self, d=None):
+        self.file_type: Optional[str] = None
+        self.file_name: Optional[str] = None
+        self.duration: Optional[int] = None
+        self.file: Optional[IO[Any]] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "CreateFileRequestBodyBuilder":
+        return CreateFileRequestBodyBuilder()
+
+
+class CreateFileRequestBodyBuilder(object):
+    def __init__(self) -> None:
+        self._create_file_request_body = CreateFileRequestBody()
+
+    def file_type(self, file_type: str) -> "CreateFileRequestBodyBuilder":
+        self._create_file_request_body.file_type = file_type
+        return self
+
+    def file_name(self, file_name: str) -> "CreateFileRequestBodyBuilder":
+        self._create_file_request_body.file_name = file_name
+        return self
+
+    def duration(self, duration: int) -> "CreateFileRequestBodyBuilder":
+        self._create_file_request_body.duration = duration
+        return self
+
+    def file(self, file: IO[Any]) -> "CreateFileRequestBodyBuilder":
+        self._create_file_request_body.file = file
+        return self
+
+    def build(self) -> "CreateFileRequestBody":
+        return self._create_file_request_body
diff --git a/lark_channel/api/im/v1/model/create_file_response.py b/lark_channel/api/im/v1/model/create_file_response.py
new file mode 100644
index 0000000..d45868c
--- /dev/null
+++ b/lark_channel/api/im/v1/model/create_file_response.py
@@ -0,0 +1,15 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+from .create_file_response_body import CreateFileResponseBody
+
+
+class CreateFileResponse(BaseResponse):
+    _types = {
+        "data": CreateFileResponseBody
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.data: Optional[CreateFileResponseBody] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/create_file_response_body.py b/lark_channel/api/im/v1/model/create_file_response_body.py
new file mode 100644
index 0000000..6a0c189
--- /dev/null
+++ b/lark_channel/api/im/v1/model/create_file_response_body.py
@@ -0,0 +1,28 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class CreateFileResponseBody(object):
+    _types = {
+        "file_key": str,
+    }
+
+    def __init__(self, d=None):
+        self.file_key: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "CreateFileResponseBodyBuilder":
+        return CreateFileResponseBodyBuilder()
+
+
+class CreateFileResponseBodyBuilder(object):
+    def __init__(self) -> None:
+        self._create_file_response_body = CreateFileResponseBody()
+
+    def file_key(self, file_key: str) -> "CreateFileResponseBodyBuilder":
+        self._create_file_response_body.file_key = file_key
+        return self
+
+    def build(self) -> "CreateFileResponseBody":
+        return self._create_file_response_body
diff --git a/lark_channel/api/im/v1/model/create_image_request.py b/lark_channel/api/im/v1/model/create_image_request.py
new file mode 100644
index 0000000..66a8c54
--- /dev/null
+++ b/lark_channel/api/im/v1/model/create_image_request.py
@@ -0,0 +1,32 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .create_image_request_body import CreateImageRequestBody
+
+
+class CreateImageRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.request_body: Optional[CreateImageRequestBody] = None
+
+    @staticmethod
+    def builder() -> "CreateImageRequestBuilder":
+        return CreateImageRequestBuilder()
+
+
+class CreateImageRequestBuilder(object):
+
+    def __init__(self) -> None:
+        create_image_request = CreateImageRequest()
+        create_image_request.http_method = HttpMethod.POST
+        create_image_request.uri = "/open-apis/im/v1/images"
+        create_image_request.token_types = {AccessTokenType.TENANT}
+        self._create_image_request: CreateImageRequest = create_image_request
+
+    def request_body(self, request_body: CreateImageRequestBody) -> "CreateImageRequestBuilder":
+        self._create_image_request.request_body = request_body
+        self._create_image_request.body = request_body
+        return self
+
+    def build(self) -> CreateImageRequest:
+        return self._create_image_request
diff --git a/lark_channel/api/im/v1/model/create_image_request_body.py b/lark_channel/api/im/v1/model/create_image_request_body.py
new file mode 100644
index 0000000..17cfcfa
--- /dev/null
+++ b/lark_channel/api/im/v1/model/create_image_request_body.py
@@ -0,0 +1,34 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class CreateImageRequestBody(object):
+    _types = {
+        "image_type": str,
+        "image": IO[Any],
+    }
+
+    def __init__(self, d=None):
+        self.image_type: Optional[str] = None
+        self.image: Optional[IO[Any]] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "CreateImageRequestBodyBuilder":
+        return CreateImageRequestBodyBuilder()
+
+
+class CreateImageRequestBodyBuilder(object):
+    def __init__(self) -> None:
+        self._create_image_request_body = CreateImageRequestBody()
+
+    def image_type(self, image_type: str) -> "CreateImageRequestBodyBuilder":
+        self._create_image_request_body.image_type = image_type
+        return self
+
+    def image(self, image: IO[Any]) -> "CreateImageRequestBodyBuilder":
+        self._create_image_request_body.image = image
+        return self
+
+    def build(self) -> "CreateImageRequestBody":
+        return self._create_image_request_body
diff --git a/lark_channel/api/im/v1/model/create_image_response.py b/lark_channel/api/im/v1/model/create_image_response.py
new file mode 100644
index 0000000..67fc269
--- /dev/null
+++ b/lark_channel/api/im/v1/model/create_image_response.py
@@ -0,0 +1,15 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+from .create_image_response_body import CreateImageResponseBody
+
+
+class CreateImageResponse(BaseResponse):
+    _types = {
+        "data": CreateImageResponseBody
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.data: Optional[CreateImageResponseBody] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/create_image_response_body.py b/lark_channel/api/im/v1/model/create_image_response_body.py
new file mode 100644
index 0000000..ef163d8
--- /dev/null
+++ b/lark_channel/api/im/v1/model/create_image_response_body.py
@@ -0,0 +1,28 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class CreateImageResponseBody(object):
+    _types = {
+        "image_key": str,
+    }
+
+    def __init__(self, d=None):
+        self.image_key: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "CreateImageResponseBodyBuilder":
+        return CreateImageResponseBodyBuilder()
+
+
+class CreateImageResponseBodyBuilder(object):
+    def __init__(self) -> None:
+        self._create_image_response_body = CreateImageResponseBody()
+
+    def image_key(self, image_key: str) -> "CreateImageResponseBodyBuilder":
+        self._create_image_response_body.image_key = image_key
+        return self
+
+    def build(self) -> "CreateImageResponseBody":
+        return self._create_image_response_body
diff --git a/lark_channel/api/im/v1/model/create_message_reaction_request.py b/lark_channel/api/im/v1/model/create_message_reaction_request.py
new file mode 100644
index 0000000..81c992a
--- /dev/null
+++ b/lark_channel/api/im/v1/model/create_message_reaction_request.py
@@ -0,0 +1,38 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .create_message_reaction_request_body import CreateMessageReactionRequestBody
+
+
+class CreateMessageReactionRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.message_id: Optional[str] = None
+        self.request_body: Optional[CreateMessageReactionRequestBody] = None
+
+    @staticmethod
+    def builder() -> "CreateMessageReactionRequestBuilder":
+        return CreateMessageReactionRequestBuilder()
+
+
+class CreateMessageReactionRequestBuilder(object):
+
+    def __init__(self) -> None:
+        create_message_reaction_request = CreateMessageReactionRequest()
+        create_message_reaction_request.http_method = HttpMethod.POST
+        create_message_reaction_request.uri = "/open-apis/im/v1/messages/:message_id/reactions"
+        create_message_reaction_request.token_types = {AccessTokenType.USER, AccessTokenType.TENANT}
+        self._create_message_reaction_request: CreateMessageReactionRequest = create_message_reaction_request
+
+    def message_id(self, message_id: str) -> "CreateMessageReactionRequestBuilder":
+        self._create_message_reaction_request.message_id = message_id
+        self._create_message_reaction_request.paths["message_id"] = str(message_id)
+        return self
+
+    def request_body(self, request_body: CreateMessageReactionRequestBody) -> "CreateMessageReactionRequestBuilder":
+        self._create_message_reaction_request.request_body = request_body
+        self._create_message_reaction_request.body = request_body
+        return self
+
+    def build(self) -> CreateMessageReactionRequest:
+        return self._create_message_reaction_request
diff --git a/lark_channel/api/im/v1/model/create_message_reaction_request_body.py b/lark_channel/api/im/v1/model/create_message_reaction_request_body.py
new file mode 100644
index 0000000..ace04b8
--- /dev/null
+++ b/lark_channel/api/im/v1/model/create_message_reaction_request_body.py
@@ -0,0 +1,29 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .emoji import Emoji
+
+
+class CreateMessageReactionRequestBody(object):
+    _types = {
+        "reaction_type": Emoji,
+    }
+
+    def __init__(self, d=None):
+        self.reaction_type: Optional[Emoji] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "CreateMessageReactionRequestBodyBuilder":
+        return CreateMessageReactionRequestBodyBuilder()
+
+
+class CreateMessageReactionRequestBodyBuilder(object):
+    def __init__(self) -> None:
+        self._create_message_reaction_request_body = CreateMessageReactionRequestBody()
+
+    def reaction_type(self, reaction_type: Emoji) -> "CreateMessageReactionRequestBodyBuilder":
+        self._create_message_reaction_request_body.reaction_type = reaction_type
+        return self
+
+    def build(self) -> "CreateMessageReactionRequestBody":
+        return self._create_message_reaction_request_body
diff --git a/lark_channel/api/im/v1/model/create_message_reaction_response.py b/lark_channel/api/im/v1/model/create_message_reaction_response.py
new file mode 100644
index 0000000..6d88f6b
--- /dev/null
+++ b/lark_channel/api/im/v1/model/create_message_reaction_response.py
@@ -0,0 +1,15 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+from .create_message_reaction_response_body import CreateMessageReactionResponseBody
+
+
+class CreateMessageReactionResponse(BaseResponse):
+    _types = {
+        "data": CreateMessageReactionResponseBody
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.data: Optional[CreateMessageReactionResponseBody] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/create_message_reaction_response_body.py b/lark_channel/api/im/v1/model/create_message_reaction_response_body.py
new file mode 100644
index 0000000..c3aa017
--- /dev/null
+++ b/lark_channel/api/im/v1/model/create_message_reaction_response_body.py
@@ -0,0 +1,48 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .operator import Operator
+from .emoji import Emoji
+
+
+class CreateMessageReactionResponseBody(object):
+    _types = {
+        "reaction_id": str,
+        "operator": Operator,
+        "action_time": int,
+        "reaction_type": Emoji,
+    }
+
+    def __init__(self, d=None):
+        self.reaction_id: Optional[str] = None
+        self.operator: Optional[Operator] = None
+        self.action_time: Optional[int] = None
+        self.reaction_type: Optional[Emoji] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "CreateMessageReactionResponseBodyBuilder":
+        return CreateMessageReactionResponseBodyBuilder()
+
+
+class CreateMessageReactionResponseBodyBuilder(object):
+    def __init__(self) -> None:
+        self._create_message_reaction_response_body = CreateMessageReactionResponseBody()
+
+    def reaction_id(self, reaction_id: str) -> "CreateMessageReactionResponseBodyBuilder":
+        self._create_message_reaction_response_body.reaction_id = reaction_id
+        return self
+
+    def operator(self, operator: Operator) -> "CreateMessageReactionResponseBodyBuilder":
+        self._create_message_reaction_response_body.operator = operator
+        return self
+
+    def action_time(self, action_time: int) -> "CreateMessageReactionResponseBodyBuilder":
+        self._create_message_reaction_response_body.action_time = action_time
+        return self
+
+    def reaction_type(self, reaction_type: Emoji) -> "CreateMessageReactionResponseBodyBuilder":
+        self._create_message_reaction_response_body.reaction_type = reaction_type
+        return self
+
+    def build(self) -> "CreateMessageReactionResponseBody":
+        return self._create_message_reaction_response_body
diff --git a/lark_channel/api/im/v1/model/create_message_request.py b/lark_channel/api/im/v1/model/create_message_request.py
new file mode 100644
index 0000000..d266d19
--- /dev/null
+++ b/lark_channel/api/im/v1/model/create_message_request.py
@@ -0,0 +1,38 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .create_message_request_body import CreateMessageRequestBody
+
+
+class CreateMessageRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.receive_id_type: Optional[str] = None
+        self.request_body: Optional[CreateMessageRequestBody] = None
+
+    @staticmethod
+    def builder() -> "CreateMessageRequestBuilder":
+        return CreateMessageRequestBuilder()
+
+
+class CreateMessageRequestBuilder(object):
+
+    def __init__(self) -> None:
+        create_message_request = CreateMessageRequest()
+        create_message_request.http_method = HttpMethod.POST
+        create_message_request.uri = "/open-apis/im/v1/messages"
+        create_message_request.token_types = {AccessTokenType.TENANT, AccessTokenType.USER}
+        self._create_message_request: CreateMessageRequest = create_message_request
+
+    def receive_id_type(self, receive_id_type: str) -> "CreateMessageRequestBuilder":
+        self._create_message_request.receive_id_type = receive_id_type
+        self._create_message_request.add_query("receive_id_type", receive_id_type)
+        return self
+
+    def request_body(self, request_body: CreateMessageRequestBody) -> "CreateMessageRequestBuilder":
+        self._create_message_request.request_body = request_body
+        self._create_message_request.body = request_body
+        return self
+
+    def build(self) -> CreateMessageRequest:
+        return self._create_message_request
diff --git a/lark_channel/api/im/v1/model/create_message_request_body.py b/lark_channel/api/im/v1/model/create_message_request_body.py
new file mode 100644
index 0000000..793d6dd
--- /dev/null
+++ b/lark_channel/api/im/v1/model/create_message_request_body.py
@@ -0,0 +1,46 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class CreateMessageRequestBody(object):
+    _types = {
+        "receive_id": str,
+        "msg_type": str,
+        "content": str,
+        "uuid": str,
+    }
+
+    def __init__(self, d=None):
+        self.receive_id: Optional[str] = None
+        self.msg_type: Optional[str] = None
+        self.content: Optional[str] = None
+        self.uuid: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "CreateMessageRequestBodyBuilder":
+        return CreateMessageRequestBodyBuilder()
+
+
+class CreateMessageRequestBodyBuilder(object):
+    def __init__(self) -> None:
+        self._create_message_request_body = CreateMessageRequestBody()
+
+    def receive_id(self, receive_id: str) -> "CreateMessageRequestBodyBuilder":
+        self._create_message_request_body.receive_id = receive_id
+        return self
+
+    def msg_type(self, msg_type: str) -> "CreateMessageRequestBodyBuilder":
+        self._create_message_request_body.msg_type = msg_type
+        return self
+
+    def content(self, content: str) -> "CreateMessageRequestBodyBuilder":
+        self._create_message_request_body.content = content
+        return self
+
+    def uuid(self, uuid: str) -> "CreateMessageRequestBodyBuilder":
+        self._create_message_request_body.uuid = uuid
+        return self
+
+    def build(self) -> "CreateMessageRequestBody":
+        return self._create_message_request_body
diff --git a/lark_channel/api/im/v1/model/create_message_response.py b/lark_channel/api/im/v1/model/create_message_response.py
new file mode 100644
index 0000000..6521da9
--- /dev/null
+++ b/lark_channel/api/im/v1/model/create_message_response.py
@@ -0,0 +1,15 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+from .create_message_response_body import CreateMessageResponseBody
+
+
+class CreateMessageResponse(BaseResponse):
+    _types = {
+        "data": CreateMessageResponseBody
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.data: Optional[CreateMessageResponseBody] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/create_message_response_body.py b/lark_channel/api/im/v1/model/create_message_response_body.py
new file mode 100644
index 0000000..78b2a83
--- /dev/null
+++ b/lark_channel/api/im/v1/model/create_message_response_body.py
@@ -0,0 +1,109 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .sender import Sender
+from .message_body import MessageBody
+from .mention import Mention
+
+
+class CreateMessageResponseBody(object):
+    _types = {
+        "message_id": str,
+        "root_id": str,
+        "parent_id": str,
+        "thread_id": str,
+        "msg_type": str,
+        "create_time": int,
+        "update_time": int,
+        "deleted": bool,
+        "updated": bool,
+        "chat_id": str,
+        "sender": Sender,
+        "body": MessageBody,
+        "mentions": List[Mention],
+        "upper_message_id": str,
+    }
+
+    def __init__(self, d=None):
+        self.message_id: Optional[str] = None
+        self.root_id: Optional[str] = None
+        self.parent_id: Optional[str] = None
+        self.thread_id: Optional[str] = None
+        self.msg_type: Optional[str] = None
+        self.create_time: Optional[int] = None
+        self.update_time: Optional[int] = None
+        self.deleted: Optional[bool] = None
+        self.updated: Optional[bool] = None
+        self.chat_id: Optional[str] = None
+        self.sender: Optional[Sender] = None
+        self.body: Optional[MessageBody] = None
+        self.mentions: Optional[List[Mention]] = None
+        self.upper_message_id: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "CreateMessageResponseBodyBuilder":
+        return CreateMessageResponseBodyBuilder()
+
+
+class CreateMessageResponseBodyBuilder(object):
+    def __init__(self) -> None:
+        self._create_message_response_body = CreateMessageResponseBody()
+
+    def message_id(self, message_id: str) -> "CreateMessageResponseBodyBuilder":
+        self._create_message_response_body.message_id = message_id
+        return self
+
+    def root_id(self, root_id: str) -> "CreateMessageResponseBodyBuilder":
+        self._create_message_response_body.root_id = root_id
+        return self
+
+    def parent_id(self, parent_id: str) -> "CreateMessageResponseBodyBuilder":
+        self._create_message_response_body.parent_id = parent_id
+        return self
+
+    def thread_id(self, thread_id: str) -> "CreateMessageResponseBodyBuilder":
+        self._create_message_response_body.thread_id = thread_id
+        return self
+
+    def msg_type(self, msg_type: str) -> "CreateMessageResponseBodyBuilder":
+        self._create_message_response_body.msg_type = msg_type
+        return self
+
+    def create_time(self, create_time: int) -> "CreateMessageResponseBodyBuilder":
+        self._create_message_response_body.create_time = create_time
+        return self
+
+    def update_time(self, update_time: int) -> "CreateMessageResponseBodyBuilder":
+        self._create_message_response_body.update_time = update_time
+        return self
+
+    def deleted(self, deleted: bool) -> "CreateMessageResponseBodyBuilder":
+        self._create_message_response_body.deleted = deleted
+        return self
+
+    def updated(self, updated: bool) -> "CreateMessageResponseBodyBuilder":
+        self._create_message_response_body.updated = updated
+        return self
+
+    def chat_id(self, chat_id: str) -> "CreateMessageResponseBodyBuilder":
+        self._create_message_response_body.chat_id = chat_id
+        return self
+
+    def sender(self, sender: Sender) -> "CreateMessageResponseBodyBuilder":
+        self._create_message_response_body.sender = sender
+        return self
+
+    def body(self, body: MessageBody) -> "CreateMessageResponseBodyBuilder":
+        self._create_message_response_body.body = body
+        return self
+
+    def mentions(self, mentions: List[Mention]) -> "CreateMessageResponseBodyBuilder":
+        self._create_message_response_body.mentions = mentions
+        return self
+
+    def upper_message_id(self, upper_message_id: str) -> "CreateMessageResponseBodyBuilder":
+        self._create_message_response_body.upper_message_id = upper_message_id
+        return self
+
+    def build(self) -> "CreateMessageResponseBody":
+        return self._create_message_response_body
diff --git a/lark_channel/api/im/v1/model/delete_chat_request.py b/lark_channel/api/im/v1/model/delete_chat_request.py
new file mode 100644
index 0000000..bd2b8c1
--- /dev/null
+++ b/lark_channel/api/im/v1/model/delete_chat_request.py
@@ -0,0 +1,31 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+
+
+class DeleteChatRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.chat_id: Optional[str] = None
+
+    @staticmethod
+    def builder() -> "DeleteChatRequestBuilder":
+        return DeleteChatRequestBuilder()
+
+
+class DeleteChatRequestBuilder(object):
+
+    def __init__(self) -> None:
+        delete_chat_request = DeleteChatRequest()
+        delete_chat_request.http_method = HttpMethod.DELETE
+        delete_chat_request.uri = "/open-apis/im/v1/chats/:chat_id"
+        delete_chat_request.token_types = {AccessTokenType.USER, AccessTokenType.TENANT}
+        self._delete_chat_request: DeleteChatRequest = delete_chat_request
+
+    def chat_id(self, chat_id: str) -> "DeleteChatRequestBuilder":
+        self._delete_chat_request.chat_id = chat_id
+        self._delete_chat_request.paths["chat_id"] = str(chat_id)
+        return self
+
+    def build(self) -> DeleteChatRequest:
+        return self._delete_chat_request
diff --git a/lark_channel/api/im/v1/model/delete_chat_response.py b/lark_channel/api/im/v1/model/delete_chat_response.py
new file mode 100644
index 0000000..f7495fe
--- /dev/null
+++ b/lark_channel/api/im/v1/model/delete_chat_response.py
@@ -0,0 +1,14 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+
+
+class DeleteChatResponse(BaseResponse):
+    _types = {
+
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/delete_message_reaction_request.py b/lark_channel/api/im/v1/model/delete_message_reaction_request.py
new file mode 100644
index 0000000..dcd262e
--- /dev/null
+++ b/lark_channel/api/im/v1/model/delete_message_reaction_request.py
@@ -0,0 +1,37 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+
+
+class DeleteMessageReactionRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.message_id: Optional[str] = None
+        self.reaction_id: Optional[str] = None
+
+    @staticmethod
+    def builder() -> "DeleteMessageReactionRequestBuilder":
+        return DeleteMessageReactionRequestBuilder()
+
+
+class DeleteMessageReactionRequestBuilder(object):
+
+    def __init__(self) -> None:
+        delete_message_reaction_request = DeleteMessageReactionRequest()
+        delete_message_reaction_request.http_method = HttpMethod.DELETE
+        delete_message_reaction_request.uri = "/open-apis/im/v1/messages/:message_id/reactions/:reaction_id"
+        delete_message_reaction_request.token_types = {AccessTokenType.USER, AccessTokenType.TENANT}
+        self._delete_message_reaction_request: DeleteMessageReactionRequest = delete_message_reaction_request
+
+    def message_id(self, message_id: str) -> "DeleteMessageReactionRequestBuilder":
+        self._delete_message_reaction_request.message_id = message_id
+        self._delete_message_reaction_request.paths["message_id"] = str(message_id)
+        return self
+
+    def reaction_id(self, reaction_id: str) -> "DeleteMessageReactionRequestBuilder":
+        self._delete_message_reaction_request.reaction_id = reaction_id
+        self._delete_message_reaction_request.paths["reaction_id"] = str(reaction_id)
+        return self
+
+    def build(self) -> DeleteMessageReactionRequest:
+        return self._delete_message_reaction_request
diff --git a/lark_channel/api/im/v1/model/delete_message_reaction_response.py b/lark_channel/api/im/v1/model/delete_message_reaction_response.py
new file mode 100644
index 0000000..4a405e4
--- /dev/null
+++ b/lark_channel/api/im/v1/model/delete_message_reaction_response.py
@@ -0,0 +1,15 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+from .delete_message_reaction_response_body import DeleteMessageReactionResponseBody
+
+
+class DeleteMessageReactionResponse(BaseResponse):
+    _types = {
+        "data": DeleteMessageReactionResponseBody
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.data: Optional[DeleteMessageReactionResponseBody] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/delete_message_reaction_response_body.py b/lark_channel/api/im/v1/model/delete_message_reaction_response_body.py
new file mode 100644
index 0000000..a200605
--- /dev/null
+++ b/lark_channel/api/im/v1/model/delete_message_reaction_response_body.py
@@ -0,0 +1,48 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .operator import Operator
+from .emoji import Emoji
+
+
+class DeleteMessageReactionResponseBody(object):
+    _types = {
+        "reaction_id": str,
+        "operator": Operator,
+        "action_time": int,
+        "reaction_type": Emoji,
+    }
+
+    def __init__(self, d=None):
+        self.reaction_id: Optional[str] = None
+        self.operator: Optional[Operator] = None
+        self.action_time: Optional[int] = None
+        self.reaction_type: Optional[Emoji] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "DeleteMessageReactionResponseBodyBuilder":
+        return DeleteMessageReactionResponseBodyBuilder()
+
+
+class DeleteMessageReactionResponseBodyBuilder(object):
+    def __init__(self) -> None:
+        self._delete_message_reaction_response_body = DeleteMessageReactionResponseBody()
+
+    def reaction_id(self, reaction_id: str) -> "DeleteMessageReactionResponseBodyBuilder":
+        self._delete_message_reaction_response_body.reaction_id = reaction_id
+        return self
+
+    def operator(self, operator: Operator) -> "DeleteMessageReactionResponseBodyBuilder":
+        self._delete_message_reaction_response_body.operator = operator
+        return self
+
+    def action_time(self, action_time: int) -> "DeleteMessageReactionResponseBodyBuilder":
+        self._delete_message_reaction_response_body.action_time = action_time
+        return self
+
+    def reaction_type(self, reaction_type: Emoji) -> "DeleteMessageReactionResponseBodyBuilder":
+        self._delete_message_reaction_response_body.reaction_type = reaction_type
+        return self
+
+    def build(self) -> "DeleteMessageReactionResponseBody":
+        return self._delete_message_reaction_response_body
diff --git a/lark_channel/api/im/v1/model/delete_message_request.py b/lark_channel/api/im/v1/model/delete_message_request.py
new file mode 100644
index 0000000..93c9fe2
--- /dev/null
+++ b/lark_channel/api/im/v1/model/delete_message_request.py
@@ -0,0 +1,31 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+
+
+class DeleteMessageRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.message_id: Optional[str] = None
+
+    @staticmethod
+    def builder() -> "DeleteMessageRequestBuilder":
+        return DeleteMessageRequestBuilder()
+
+
+class DeleteMessageRequestBuilder(object):
+
+    def __init__(self) -> None:
+        delete_message_request = DeleteMessageRequest()
+        delete_message_request.http_method = HttpMethod.DELETE
+        delete_message_request.uri = "/open-apis/im/v1/messages/:message_id"
+        delete_message_request.token_types = {AccessTokenType.TENANT, AccessTokenType.USER}
+        self._delete_message_request: DeleteMessageRequest = delete_message_request
+
+    def message_id(self, message_id: str) -> "DeleteMessageRequestBuilder":
+        self._delete_message_request.message_id = message_id
+        self._delete_message_request.paths["message_id"] = str(message_id)
+        return self
+
+    def build(self) -> DeleteMessageRequest:
+        return self._delete_message_request
diff --git a/lark_channel/api/im/v1/model/delete_message_response.py b/lark_channel/api/im/v1/model/delete_message_response.py
new file mode 100644
index 0000000..a8d38e6
--- /dev/null
+++ b/lark_channel/api/im/v1/model/delete_message_response.py
@@ -0,0 +1,14 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+
+
+class DeleteMessageResponse(BaseResponse):
+    _types = {
+
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/emoji.py b/lark_channel/api/im/v1/model/emoji.py
new file mode 100644
index 0000000..4783db1
--- /dev/null
+++ b/lark_channel/api/im/v1/model/emoji.py
@@ -0,0 +1,28 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class Emoji(object):
+    _types = {
+        "emoji_type": str,
+    }
+
+    def __init__(self, d=None):
+        self.emoji_type: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "EmojiBuilder":
+        return EmojiBuilder()
+
+
+class EmojiBuilder(object):
+    def __init__(self) -> None:
+        self._emoji = Emoji()
+
+    def emoji_type(self, emoji_type: str) -> "EmojiBuilder":
+        self._emoji.emoji_type = emoji_type
+        return self
+
+    def build(self) -> "Emoji":
+        return self._emoji
diff --git a/lark_channel/api/im/v1/model/event_message.py b/lark_channel/api/im/v1/model/event_message.py
new file mode 100644
index 0000000..1d42a67
--- /dev/null
+++ b/lark_channel/api/im/v1/model/event_message.py
@@ -0,0 +1,95 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .mention_event import MentionEvent
+
+
+class EventMessage(object):
+    _types = {
+        "message_id": str,
+        "root_id": str,
+        "parent_id": str,
+        "create_time": int,
+        "update_time": int,
+        "chat_id": str,
+        "thread_id": str,
+        "chat_type": str,
+        "message_type": str,
+        "content": str,
+        "mentions": List[MentionEvent],
+        "user_agent": str,
+    }
+
+    def __init__(self, d=None):
+        self.message_id: Optional[str] = None
+        self.root_id: Optional[str] = None
+        self.parent_id: Optional[str] = None
+        self.create_time: Optional[int] = None
+        self.update_time: Optional[int] = None
+        self.chat_id: Optional[str] = None
+        self.thread_id: Optional[str] = None
+        self.chat_type: Optional[str] = None
+        self.message_type: Optional[str] = None
+        self.content: Optional[str] = None
+        self.mentions: Optional[List[MentionEvent]] = None
+        self.user_agent: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "EventMessageBuilder":
+        return EventMessageBuilder()
+
+
+class EventMessageBuilder(object):
+    def __init__(self) -> None:
+        self._event_message = EventMessage()
+
+    def message_id(self, message_id: str) -> "EventMessageBuilder":
+        self._event_message.message_id = message_id
+        return self
+
+    def root_id(self, root_id: str) -> "EventMessageBuilder":
+        self._event_message.root_id = root_id
+        return self
+
+    def parent_id(self, parent_id: str) -> "EventMessageBuilder":
+        self._event_message.parent_id = parent_id
+        return self
+
+    def create_time(self, create_time: int) -> "EventMessageBuilder":
+        self._event_message.create_time = create_time
+        return self
+
+    def update_time(self, update_time: int) -> "EventMessageBuilder":
+        self._event_message.update_time = update_time
+        return self
+
+    def chat_id(self, chat_id: str) -> "EventMessageBuilder":
+        self._event_message.chat_id = chat_id
+        return self
+
+    def thread_id(self, thread_id: str) -> "EventMessageBuilder":
+        self._event_message.thread_id = thread_id
+        return self
+
+    def chat_type(self, chat_type: str) -> "EventMessageBuilder":
+        self._event_message.chat_type = chat_type
+        return self
+
+    def message_type(self, message_type: str) -> "EventMessageBuilder":
+        self._event_message.message_type = message_type
+        return self
+
+    def content(self, content: str) -> "EventMessageBuilder":
+        self._event_message.content = content
+        return self
+
+    def mentions(self, mentions: List[MentionEvent]) -> "EventMessageBuilder":
+        self._event_message.mentions = mentions
+        return self
+
+    def user_agent(self, user_agent: str) -> "EventMessageBuilder":
+        self._event_message.user_agent = user_agent
+        return self
+
+    def build(self) -> "EventMessage":
+        return self._event_message
diff --git a/lark_channel/api/im/v1/model/event_message_reader.py b/lark_channel/api/im/v1/model/event_message_reader.py
new file mode 100644
index 0000000..1e7ad0a
--- /dev/null
+++ b/lark_channel/api/im/v1/model/event_message_reader.py
@@ -0,0 +1,41 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .user_id import UserId
+
+
+class EventMessageReader(object):
+    _types = {
+        "reader_id": UserId,
+        "read_time": str,
+        "tenant_key": str,
+    }
+
+    def __init__(self, d=None):
+        self.reader_id: Optional[UserId] = None
+        self.read_time: Optional[str] = None
+        self.tenant_key: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "EventMessageReaderBuilder":
+        return EventMessageReaderBuilder()
+
+
+class EventMessageReaderBuilder(object):
+    def __init__(self) -> None:
+        self._event_message_reader = EventMessageReader()
+
+    def reader_id(self, reader_id: UserId) -> "EventMessageReaderBuilder":
+        self._event_message_reader.reader_id = reader_id
+        return self
+
+    def read_time(self, read_time: str) -> "EventMessageReaderBuilder":
+        self._event_message_reader.read_time = read_time
+        return self
+
+    def tenant_key(self, tenant_key: str) -> "EventMessageReaderBuilder":
+        self._event_message_reader.tenant_key = tenant_key
+        return self
+
+    def build(self) -> "EventMessageReader":
+        return self._event_message_reader
diff --git a/lark_channel/api/im/v1/model/event_sender.py b/lark_channel/api/im/v1/model/event_sender.py
new file mode 100644
index 0000000..c58b1db
--- /dev/null
+++ b/lark_channel/api/im/v1/model/event_sender.py
@@ -0,0 +1,41 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .user_id import UserId
+
+
+class EventSender(object):
+    _types = {
+        "sender_id": UserId,
+        "sender_type": str,
+        "tenant_key": str,
+    }
+
+    def __init__(self, d=None):
+        self.sender_id: Optional[UserId] = None
+        self.sender_type: Optional[str] = None
+        self.tenant_key: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "EventSenderBuilder":
+        return EventSenderBuilder()
+
+
+class EventSenderBuilder(object):
+    def __init__(self) -> None:
+        self._event_sender = EventSender()
+
+    def sender_id(self, sender_id: UserId) -> "EventSenderBuilder":
+        self._event_sender.sender_id = sender_id
+        return self
+
+    def sender_type(self, sender_type: str) -> "EventSenderBuilder":
+        self._event_sender.sender_type = sender_type
+        return self
+
+    def tenant_key(self, tenant_key: str) -> "EventSenderBuilder":
+        self._event_sender.tenant_key = tenant_key
+        return self
+
+    def build(self) -> "EventSender":
+        return self._event_sender
diff --git a/lark_channel/api/im/v1/model/follow_up.py b/lark_channel/api/im/v1/model/follow_up.py
new file mode 100644
index 0000000..7e4b5ab
--- /dev/null
+++ b/lark_channel/api/im/v1/model/follow_up.py
@@ -0,0 +1,35 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .i18n_content import I18nContent
+
+
+class FollowUp(object):
+    _types = {
+        "content": str,
+        "i18n_contents": List[I18nContent],
+    }
+
+    def __init__(self, d=None):
+        self.content: Optional[str] = None
+        self.i18n_contents: Optional[List[I18nContent]] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "FollowUpBuilder":
+        return FollowUpBuilder()
+
+
+class FollowUpBuilder(object):
+    def __init__(self) -> None:
+        self._follow_up = FollowUp()
+
+    def content(self, content: str) -> "FollowUpBuilder":
+        self._follow_up.content = content
+        return self
+
+    def i18n_contents(self, i18n_contents: List[I18nContent]) -> "FollowUpBuilder":
+        self._follow_up.i18n_contents = i18n_contents
+        return self
+
+    def build(self) -> "FollowUp":
+        return self._follow_up
diff --git a/lark_channel/api/im/v1/model/forward_message_request.py b/lark_channel/api/im/v1/model/forward_message_request.py
new file mode 100644
index 0000000..45cbe3d
--- /dev/null
+++ b/lark_channel/api/im/v1/model/forward_message_request.py
@@ -0,0 +1,50 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .forward_message_request_body import ForwardMessageRequestBody
+
+
+class ForwardMessageRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.receive_id_type: Optional[str] = None
+        self.uuid: Optional[str] = None
+        self.message_id: Optional[str] = None
+        self.request_body: Optional[ForwardMessageRequestBody] = None
+
+    @staticmethod
+    def builder() -> "ForwardMessageRequestBuilder":
+        return ForwardMessageRequestBuilder()
+
+
+class ForwardMessageRequestBuilder(object):
+
+    def __init__(self) -> None:
+        forward_message_request = ForwardMessageRequest()
+        forward_message_request.http_method = HttpMethod.POST
+        forward_message_request.uri = "/open-apis/im/v1/messages/:message_id/forward"
+        forward_message_request.token_types = {AccessTokenType.TENANT}
+        self._forward_message_request: ForwardMessageRequest = forward_message_request
+
+    def receive_id_type(self, receive_id_type: str) -> "ForwardMessageRequestBuilder":
+        self._forward_message_request.receive_id_type = receive_id_type
+        self._forward_message_request.add_query("receive_id_type", receive_id_type)
+        return self
+
+    def uuid(self, uuid: str) -> "ForwardMessageRequestBuilder":
+        self._forward_message_request.uuid = uuid
+        self._forward_message_request.add_query("uuid", uuid)
+        return self
+
+    def message_id(self, message_id: str) -> "ForwardMessageRequestBuilder":
+        self._forward_message_request.message_id = message_id
+        self._forward_message_request.paths["message_id"] = str(message_id)
+        return self
+
+    def request_body(self, request_body: ForwardMessageRequestBody) -> "ForwardMessageRequestBuilder":
+        self._forward_message_request.request_body = request_body
+        self._forward_message_request.body = request_body
+        return self
+
+    def build(self) -> ForwardMessageRequest:
+        return self._forward_message_request
diff --git a/lark_channel/api/im/v1/model/forward_message_request_body.py b/lark_channel/api/im/v1/model/forward_message_request_body.py
new file mode 100644
index 0000000..f550b04
--- /dev/null
+++ b/lark_channel/api/im/v1/model/forward_message_request_body.py
@@ -0,0 +1,28 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class ForwardMessageRequestBody(object):
+    _types = {
+        "receive_id": str,
+    }
+
+    def __init__(self, d=None):
+        self.receive_id: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "ForwardMessageRequestBodyBuilder":
+        return ForwardMessageRequestBodyBuilder()
+
+
+class ForwardMessageRequestBodyBuilder(object):
+    def __init__(self) -> None:
+        self._forward_message_request_body = ForwardMessageRequestBody()
+
+    def receive_id(self, receive_id: str) -> "ForwardMessageRequestBodyBuilder":
+        self._forward_message_request_body.receive_id = receive_id
+        return self
+
+    def build(self) -> "ForwardMessageRequestBody":
+        return self._forward_message_request_body
diff --git a/lark_channel/api/im/v1/model/forward_message_response.py b/lark_channel/api/im/v1/model/forward_message_response.py
new file mode 100644
index 0000000..72b5a3f
--- /dev/null
+++ b/lark_channel/api/im/v1/model/forward_message_response.py
@@ -0,0 +1,15 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+from .forward_message_response_body import ForwardMessageResponseBody
+
+
+class ForwardMessageResponse(BaseResponse):
+    _types = {
+        "data": ForwardMessageResponseBody
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.data: Optional[ForwardMessageResponseBody] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/forward_message_response_body.py b/lark_channel/api/im/v1/model/forward_message_response_body.py
new file mode 100644
index 0000000..43971d1
--- /dev/null
+++ b/lark_channel/api/im/v1/model/forward_message_response_body.py
@@ -0,0 +1,109 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .sender import Sender
+from .message_body import MessageBody
+from .mention import Mention
+
+
+class ForwardMessageResponseBody(object):
+    _types = {
+        "message_id": str,
+        "root_id": str,
+        "parent_id": str,
+        "thread_id": str,
+        "msg_type": str,
+        "create_time": int,
+        "update_time": int,
+        "deleted": bool,
+        "updated": bool,
+        "chat_id": str,
+        "sender": Sender,
+        "body": MessageBody,
+        "mentions": List[Mention],
+        "upper_message_id": str,
+    }
+
+    def __init__(self, d=None):
+        self.message_id: Optional[str] = None
+        self.root_id: Optional[str] = None
+        self.parent_id: Optional[str] = None
+        self.thread_id: Optional[str] = None
+        self.msg_type: Optional[str] = None
+        self.create_time: Optional[int] = None
+        self.update_time: Optional[int] = None
+        self.deleted: Optional[bool] = None
+        self.updated: Optional[bool] = None
+        self.chat_id: Optional[str] = None
+        self.sender: Optional[Sender] = None
+        self.body: Optional[MessageBody] = None
+        self.mentions: Optional[List[Mention]] = None
+        self.upper_message_id: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "ForwardMessageResponseBodyBuilder":
+        return ForwardMessageResponseBodyBuilder()
+
+
+class ForwardMessageResponseBodyBuilder(object):
+    def __init__(self) -> None:
+        self._forward_message_response_body = ForwardMessageResponseBody()
+
+    def message_id(self, message_id: str) -> "ForwardMessageResponseBodyBuilder":
+        self._forward_message_response_body.message_id = message_id
+        return self
+
+    def root_id(self, root_id: str) -> "ForwardMessageResponseBodyBuilder":
+        self._forward_message_response_body.root_id = root_id
+        return self
+
+    def parent_id(self, parent_id: str) -> "ForwardMessageResponseBodyBuilder":
+        self._forward_message_response_body.parent_id = parent_id
+        return self
+
+    def thread_id(self, thread_id: str) -> "ForwardMessageResponseBodyBuilder":
+        self._forward_message_response_body.thread_id = thread_id
+        return self
+
+    def msg_type(self, msg_type: str) -> "ForwardMessageResponseBodyBuilder":
+        self._forward_message_response_body.msg_type = msg_type
+        return self
+
+    def create_time(self, create_time: int) -> "ForwardMessageResponseBodyBuilder":
+        self._forward_message_response_body.create_time = create_time
+        return self
+
+    def update_time(self, update_time: int) -> "ForwardMessageResponseBodyBuilder":
+        self._forward_message_response_body.update_time = update_time
+        return self
+
+    def deleted(self, deleted: bool) -> "ForwardMessageResponseBodyBuilder":
+        self._forward_message_response_body.deleted = deleted
+        return self
+
+    def updated(self, updated: bool) -> "ForwardMessageResponseBodyBuilder":
+        self._forward_message_response_body.updated = updated
+        return self
+
+    def chat_id(self, chat_id: str) -> "ForwardMessageResponseBodyBuilder":
+        self._forward_message_response_body.chat_id = chat_id
+        return self
+
+    def sender(self, sender: Sender) -> "ForwardMessageResponseBodyBuilder":
+        self._forward_message_response_body.sender = sender
+        return self
+
+    def body(self, body: MessageBody) -> "ForwardMessageResponseBodyBuilder":
+        self._forward_message_response_body.body = body
+        return self
+
+    def mentions(self, mentions: List[Mention]) -> "ForwardMessageResponseBodyBuilder":
+        self._forward_message_response_body.mentions = mentions
+        return self
+
+    def upper_message_id(self, upper_message_id: str) -> "ForwardMessageResponseBodyBuilder":
+        self._forward_message_response_body.upper_message_id = upper_message_id
+        return self
+
+    def build(self) -> "ForwardMessageResponseBody":
+        return self._forward_message_response_body
diff --git a/lark_channel/api/im/v1/model/get_chat_request.py b/lark_channel/api/im/v1/model/get_chat_request.py
new file mode 100644
index 0000000..e4c394b
--- /dev/null
+++ b/lark_channel/api/im/v1/model/get_chat_request.py
@@ -0,0 +1,37 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+
+
+class GetChatRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.user_id_type: Optional[str] = None
+        self.chat_id: Optional[str] = None
+
+    @staticmethod
+    def builder() -> "GetChatRequestBuilder":
+        return GetChatRequestBuilder()
+
+
+class GetChatRequestBuilder(object):
+
+    def __init__(self) -> None:
+        get_chat_request = GetChatRequest()
+        get_chat_request.http_method = HttpMethod.GET
+        get_chat_request.uri = "/open-apis/im/v1/chats/:chat_id"
+        get_chat_request.token_types = {AccessTokenType.USER, AccessTokenType.TENANT}
+        self._get_chat_request: GetChatRequest = get_chat_request
+
+    def user_id_type(self, user_id_type: str) -> "GetChatRequestBuilder":
+        self._get_chat_request.user_id_type = user_id_type
+        self._get_chat_request.add_query("user_id_type", user_id_type)
+        return self
+
+    def chat_id(self, chat_id: str) -> "GetChatRequestBuilder":
+        self._get_chat_request.chat_id = chat_id
+        self._get_chat_request.paths["chat_id"] = str(chat_id)
+        return self
+
+    def build(self) -> GetChatRequest:
+        return self._get_chat_request
diff --git a/lark_channel/api/im/v1/model/get_chat_response.py b/lark_channel/api/im/v1/model/get_chat_response.py
new file mode 100644
index 0000000..00d800b
--- /dev/null
+++ b/lark_channel/api/im/v1/model/get_chat_response.py
@@ -0,0 +1,15 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+from .get_chat_response_body import GetChatResponseBody
+
+
+class GetChatResponse(BaseResponse):
+    _types = {
+        "data": GetChatResponseBody
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.data: Optional[GetChatResponseBody] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/get_chat_response_body.py b/lark_channel/api/im/v1/model/get_chat_response_body.py
new file mode 100644
index 0000000..074a2f4
--- /dev/null
+++ b/lark_channel/api/im/v1/model/get_chat_response_body.py
@@ -0,0 +1,216 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .i18n_names import I18nNames
+from .restricted_mode_setting import RestrictedModeSetting
+
+
+class GetChatResponseBody(object):
+    _types = {
+        "avatar": str,
+        "name": str,
+        "description": str,
+        "i18n_names": I18nNames,
+        "add_member_permission": str,
+        "share_card_permission": str,
+        "at_all_permission": str,
+        "edit_permission": str,
+        "owner_id_type": str,
+        "owner_id": str,
+        "user_manager_id_list": List[str],
+        "bot_manager_id_list": List[str],
+        "group_message_type": str,
+        "chat_mode": str,
+        "chat_type": str,
+        "chat_tag": str,
+        "join_message_visibility": str,
+        "leave_message_visibility": str,
+        "membership_approval": str,
+        "moderation_permission": str,
+        "external": bool,
+        "tenant_key": str,
+        "user_count": str,
+        "bot_count": str,
+        "labels": List[str],
+        "toolkit_ids": List[int],
+        "restricted_mode_setting": RestrictedModeSetting,
+        "urgent_setting": str,
+        "video_conference_setting": str,
+        "pin_manage_setting": str,
+        "hide_member_count_setting": str,
+        "chat_status": str,
+    }
+
+    def __init__(self, d=None):
+        self.avatar: Optional[str] = None
+        self.name: Optional[str] = None
+        self.description: Optional[str] = None
+        self.i18n_names: Optional[I18nNames] = None
+        self.add_member_permission: Optional[str] = None
+        self.share_card_permission: Optional[str] = None
+        self.at_all_permission: Optional[str] = None
+        self.edit_permission: Optional[str] = None
+        self.owner_id_type: Optional[str] = None
+        self.owner_id: Optional[str] = None
+        self.user_manager_id_list: Optional[List[str]] = None
+        self.bot_manager_id_list: Optional[List[str]] = None
+        self.group_message_type: Optional[str] = None
+        self.chat_mode: Optional[str] = None
+        self.chat_type: Optional[str] = None
+        self.chat_tag: Optional[str] = None
+        self.join_message_visibility: Optional[str] = None
+        self.leave_message_visibility: Optional[str] = None
+        self.membership_approval: Optional[str] = None
+        self.moderation_permission: Optional[str] = None
+        self.external: Optional[bool] = None
+        self.tenant_key: Optional[str] = None
+        self.user_count: Optional[str] = None
+        self.bot_count: Optional[str] = None
+        self.labels: Optional[List[str]] = None
+        self.toolkit_ids: Optional[List[int]] = None
+        self.restricted_mode_setting: Optional[RestrictedModeSetting] = None
+        self.urgent_setting: Optional[str] = None
+        self.video_conference_setting: Optional[str] = None
+        self.pin_manage_setting: Optional[str] = None
+        self.hide_member_count_setting: Optional[str] = None
+        self.chat_status: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "GetChatResponseBodyBuilder":
+        return GetChatResponseBodyBuilder()
+
+
+class GetChatResponseBodyBuilder(object):
+    def __init__(self) -> None:
+        self._get_chat_response_body = GetChatResponseBody()
+
+    def avatar(self, avatar: str) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.avatar = avatar
+        return self
+
+    def name(self, name: str) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.name = name
+        return self
+
+    def description(self, description: str) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.description = description
+        return self
+
+    def i18n_names(self, i18n_names: I18nNames) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.i18n_names = i18n_names
+        return self
+
+    def add_member_permission(self, add_member_permission: str) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.add_member_permission = add_member_permission
+        return self
+
+    def share_card_permission(self, share_card_permission: str) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.share_card_permission = share_card_permission
+        return self
+
+    def at_all_permission(self, at_all_permission: str) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.at_all_permission = at_all_permission
+        return self
+
+    def edit_permission(self, edit_permission: str) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.edit_permission = edit_permission
+        return self
+
+    def owner_id_type(self, owner_id_type: str) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.owner_id_type = owner_id_type
+        return self
+
+    def owner_id(self, owner_id: str) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.owner_id = owner_id
+        return self
+
+    def user_manager_id_list(self, user_manager_id_list: List[str]) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.user_manager_id_list = user_manager_id_list
+        return self
+
+    def bot_manager_id_list(self, bot_manager_id_list: List[str]) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.bot_manager_id_list = bot_manager_id_list
+        return self
+
+    def group_message_type(self, group_message_type: str) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.group_message_type = group_message_type
+        return self
+
+    def chat_mode(self, chat_mode: str) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.chat_mode = chat_mode
+        return self
+
+    def chat_type(self, chat_type: str) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.chat_type = chat_type
+        return self
+
+    def chat_tag(self, chat_tag: str) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.chat_tag = chat_tag
+        return self
+
+    def join_message_visibility(self, join_message_visibility: str) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.join_message_visibility = join_message_visibility
+        return self
+
+    def leave_message_visibility(self, leave_message_visibility: str) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.leave_message_visibility = leave_message_visibility
+        return self
+
+    def membership_approval(self, membership_approval: str) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.membership_approval = membership_approval
+        return self
+
+    def moderation_permission(self, moderation_permission: str) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.moderation_permission = moderation_permission
+        return self
+
+    def external(self, external: bool) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.external = external
+        return self
+
+    def tenant_key(self, tenant_key: str) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.tenant_key = tenant_key
+        return self
+
+    def user_count(self, user_count: str) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.user_count = user_count
+        return self
+
+    def bot_count(self, bot_count: str) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.bot_count = bot_count
+        return self
+
+    def labels(self, labels: List[str]) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.labels = labels
+        return self
+
+    def toolkit_ids(self, toolkit_ids: List[int]) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.toolkit_ids = toolkit_ids
+        return self
+
+    def restricted_mode_setting(self, restricted_mode_setting: RestrictedModeSetting) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.restricted_mode_setting = restricted_mode_setting
+        return self
+
+    def urgent_setting(self, urgent_setting: str) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.urgent_setting = urgent_setting
+        return self
+
+    def video_conference_setting(self, video_conference_setting: str) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.video_conference_setting = video_conference_setting
+        return self
+
+    def pin_manage_setting(self, pin_manage_setting: str) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.pin_manage_setting = pin_manage_setting
+        return self
+
+    def hide_member_count_setting(self, hide_member_count_setting: str) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.hide_member_count_setting = hide_member_count_setting
+        return self
+
+    def chat_status(self, chat_status: str) -> "GetChatResponseBodyBuilder":
+        self._get_chat_response_body.chat_status = chat_status
+        return self
+
+    def build(self) -> "GetChatResponseBody":
+        return self._get_chat_response_body
diff --git a/lark_channel/api/im/v1/model/get_file_request.py b/lark_channel/api/im/v1/model/get_file_request.py
new file mode 100644
index 0000000..e2f833c
--- /dev/null
+++ b/lark_channel/api/im/v1/model/get_file_request.py
@@ -0,0 +1,31 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+
+
+class GetFileRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.file_key: Optional[str] = None
+
+    @staticmethod
+    def builder() -> "GetFileRequestBuilder":
+        return GetFileRequestBuilder()
+
+
+class GetFileRequestBuilder(object):
+
+    def __init__(self) -> None:
+        get_file_request = GetFileRequest()
+        get_file_request.http_method = HttpMethod.GET
+        get_file_request.uri = "/open-apis/im/v1/files/:file_key"
+        get_file_request.token_types = {AccessTokenType.TENANT}
+        self._get_file_request: GetFileRequest = get_file_request
+
+    def file_key(self, file_key: str) -> "GetFileRequestBuilder":
+        self._get_file_request.file_key = file_key
+        self._get_file_request.paths["file_key"] = str(file_key)
+        return self
+
+    def build(self) -> GetFileRequest:
+        return self._get_file_request
diff --git a/lark_channel/api/im/v1/model/get_file_response.py b/lark_channel/api/im/v1/model/get_file_response.py
new file mode 100644
index 0000000..b67cea2
--- /dev/null
+++ b/lark_channel/api/im/v1/model/get_file_response.py
@@ -0,0 +1,16 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+
+
+class GetFileResponse(BaseResponse):
+    _types = {
+        "file": IO[Any],
+        "file_name": str,
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.file: Optional[IO[Any]] = None
+        self.file_name: Optional[str] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/get_image_request.py b/lark_channel/api/im/v1/model/get_image_request.py
new file mode 100644
index 0000000..f868bee
--- /dev/null
+++ b/lark_channel/api/im/v1/model/get_image_request.py
@@ -0,0 +1,31 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+
+
+class GetImageRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.image_key: Optional[str] = None
+
+    @staticmethod
+    def builder() -> "GetImageRequestBuilder":
+        return GetImageRequestBuilder()
+
+
+class GetImageRequestBuilder(object):
+
+    def __init__(self) -> None:
+        get_image_request = GetImageRequest()
+        get_image_request.http_method = HttpMethod.GET
+        get_image_request.uri = "/open-apis/im/v1/images/:image_key"
+        get_image_request.token_types = {AccessTokenType.TENANT}
+        self._get_image_request: GetImageRequest = get_image_request
+
+    def image_key(self, image_key: str) -> "GetImageRequestBuilder":
+        self._get_image_request.image_key = image_key
+        self._get_image_request.paths["image_key"] = str(image_key)
+        return self
+
+    def build(self) -> GetImageRequest:
+        return self._get_image_request
diff --git a/lark_channel/api/im/v1/model/get_image_response.py b/lark_channel/api/im/v1/model/get_image_response.py
new file mode 100644
index 0000000..f550ae5
--- /dev/null
+++ b/lark_channel/api/im/v1/model/get_image_response.py
@@ -0,0 +1,16 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+
+
+class GetImageResponse(BaseResponse):
+    _types = {
+        "file": IO[Any],
+        "file_name": str,
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.file: Optional[IO[Any]] = None
+        self.file_name: Optional[str] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/get_message_request.py b/lark_channel/api/im/v1/model/get_message_request.py
new file mode 100644
index 0000000..214b90d
--- /dev/null
+++ b/lark_channel/api/im/v1/model/get_message_request.py
@@ -0,0 +1,37 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+
+
+class GetMessageRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.user_id_type: Optional[str] = None
+        self.message_id: Optional[str] = None
+
+    @staticmethod
+    def builder() -> "GetMessageRequestBuilder":
+        return GetMessageRequestBuilder()
+
+
+class GetMessageRequestBuilder(object):
+
+    def __init__(self) -> None:
+        get_message_request = GetMessageRequest()
+        get_message_request.http_method = HttpMethod.GET
+        get_message_request.uri = "/open-apis/im/v1/messages/:message_id"
+        get_message_request.token_types = {AccessTokenType.TENANT, AccessTokenType.USER}
+        self._get_message_request: GetMessageRequest = get_message_request
+
+    def user_id_type(self, user_id_type: str) -> "GetMessageRequestBuilder":
+        self._get_message_request.user_id_type = user_id_type
+        self._get_message_request.add_query("user_id_type", user_id_type)
+        return self
+
+    def message_id(self, message_id: str) -> "GetMessageRequestBuilder":
+        self._get_message_request.message_id = message_id
+        self._get_message_request.paths["message_id"] = str(message_id)
+        return self
+
+    def build(self) -> GetMessageRequest:
+        return self._get_message_request
diff --git a/lark_channel/api/im/v1/model/get_message_resource_request.py b/lark_channel/api/im/v1/model/get_message_resource_request.py
new file mode 100644
index 0000000..696d709
--- /dev/null
+++ b/lark_channel/api/im/v1/model/get_message_resource_request.py
@@ -0,0 +1,43 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+
+
+class GetMessageResourceRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.type: Optional[str] = None
+        self.message_id: Optional[str] = None
+        self.file_key: Optional[str] = None
+
+    @staticmethod
+    def builder() -> "GetMessageResourceRequestBuilder":
+        return GetMessageResourceRequestBuilder()
+
+
+class GetMessageResourceRequestBuilder(object):
+
+    def __init__(self) -> None:
+        get_message_resource_request = GetMessageResourceRequest()
+        get_message_resource_request.http_method = HttpMethod.GET
+        get_message_resource_request.uri = "/open-apis/im/v1/messages/:message_id/resources/:file_key"
+        get_message_resource_request.token_types = {AccessTokenType.TENANT}
+        self._get_message_resource_request: GetMessageResourceRequest = get_message_resource_request
+
+    def type(self, type: str) -> "GetMessageResourceRequestBuilder":
+        self._get_message_resource_request.type = type
+        self._get_message_resource_request.add_query("type", type)
+        return self
+
+    def message_id(self, message_id: str) -> "GetMessageResourceRequestBuilder":
+        self._get_message_resource_request.message_id = message_id
+        self._get_message_resource_request.paths["message_id"] = str(message_id)
+        return self
+
+    def file_key(self, file_key: str) -> "GetMessageResourceRequestBuilder":
+        self._get_message_resource_request.file_key = file_key
+        self._get_message_resource_request.paths["file_key"] = str(file_key)
+        return self
+
+    def build(self) -> GetMessageResourceRequest:
+        return self._get_message_resource_request
diff --git a/lark_channel/api/im/v1/model/get_message_resource_response.py b/lark_channel/api/im/v1/model/get_message_resource_response.py
new file mode 100644
index 0000000..d1e5a39
--- /dev/null
+++ b/lark_channel/api/im/v1/model/get_message_resource_response.py
@@ -0,0 +1,16 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+
+
+class GetMessageResourceResponse(BaseResponse):
+    _types = {
+        "file": IO[Any],
+        "file_name": str,
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.file: Optional[IO[Any]] = None
+        self.file_name: Optional[str] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/get_message_response.py b/lark_channel/api/im/v1/model/get_message_response.py
new file mode 100644
index 0000000..444fda2
--- /dev/null
+++ b/lark_channel/api/im/v1/model/get_message_response.py
@@ -0,0 +1,15 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+from .get_message_response_body import GetMessageResponseBody
+
+
+class GetMessageResponse(BaseResponse):
+    _types = {
+        "data": GetMessageResponseBody
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.data: Optional[GetMessageResponseBody] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/get_message_response_body.py b/lark_channel/api/im/v1/model/get_message_response_body.py
new file mode 100644
index 0000000..b77b48b
--- /dev/null
+++ b/lark_channel/api/im/v1/model/get_message_response_body.py
@@ -0,0 +1,29 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .message import Message
+
+
+class GetMessageResponseBody(object):
+    _types = {
+        "items": List[Message],
+    }
+
+    def __init__(self, d=None):
+        self.items: Optional[List[Message]] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "GetMessageResponseBodyBuilder":
+        return GetMessageResponseBodyBuilder()
+
+
+class GetMessageResponseBodyBuilder(object):
+    def __init__(self) -> None:
+        self._get_message_response_body = GetMessageResponseBody()
+
+    def items(self, items: List[Message]) -> "GetMessageResponseBodyBuilder":
+        self._get_message_response_body.items = items
+        return self
+
+    def build(self) -> "GetMessageResponseBody":
+        return self._get_message_response_body
diff --git a/lark_channel/api/im/v1/model/i18n_content.py b/lark_channel/api/im/v1/model/i18n_content.py
new file mode 100644
index 0000000..5525c9c
--- /dev/null
+++ b/lark_channel/api/im/v1/model/i18n_content.py
@@ -0,0 +1,34 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class I18nContent(object):
+    _types = {
+        "content": str,
+        "language": str,
+    }
+
+    def __init__(self, d=None):
+        self.content: Optional[str] = None
+        self.language: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "I18nContentBuilder":
+        return I18nContentBuilder()
+
+
+class I18nContentBuilder(object):
+    def __init__(self) -> None:
+        self._i18n_content = I18nContent()
+
+    def content(self, content: str) -> "I18nContentBuilder":
+        self._i18n_content.content = content
+        return self
+
+    def language(self, language: str) -> "I18nContentBuilder":
+        self._i18n_content.language = language
+        return self
+
+    def build(self) -> "I18nContent":
+        return self._i18n_content
diff --git a/lark_channel/api/im/v1/model/i18n_names.py b/lark_channel/api/im/v1/model/i18n_names.py
new file mode 100644
index 0000000..3fb13a5
--- /dev/null
+++ b/lark_channel/api/im/v1/model/i18n_names.py
@@ -0,0 +1,40 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class I18nNames(object):
+    _types = {
+        "zh_cn": str,
+        "en_us": str,
+        "ja_jp": str,
+    }
+
+    def __init__(self, d=None):
+        self.zh_cn: Optional[str] = None
+        self.en_us: Optional[str] = None
+        self.ja_jp: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "I18nNamesBuilder":
+        return I18nNamesBuilder()
+
+
+class I18nNamesBuilder(object):
+    def __init__(self) -> None:
+        self._i18n_names = I18nNames()
+
+    def zh_cn(self, zh_cn: str) -> "I18nNamesBuilder":
+        self._i18n_names.zh_cn = zh_cn
+        return self
+
+    def en_us(self, en_us: str) -> "I18nNamesBuilder":
+        self._i18n_names.en_us = en_us
+        return self
+
+    def ja_jp(self, ja_jp: str) -> "I18nNamesBuilder":
+        self._i18n_names.ja_jp = ja_jp
+        return self
+
+    def build(self) -> "I18nNames":
+        return self._i18n_names
diff --git a/lark_channel/api/im/v1/model/link_chat_request.py b/lark_channel/api/im/v1/model/link_chat_request.py
new file mode 100644
index 0000000..0fa4194
--- /dev/null
+++ b/lark_channel/api/im/v1/model/link_chat_request.py
@@ -0,0 +1,38 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .link_chat_request_body import LinkChatRequestBody
+
+
+class LinkChatRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.chat_id: Optional[str] = None
+        self.request_body: Optional[LinkChatRequestBody] = None
+
+    @staticmethod
+    def builder() -> "LinkChatRequestBuilder":
+        return LinkChatRequestBuilder()
+
+
+class LinkChatRequestBuilder(object):
+
+    def __init__(self) -> None:
+        link_chat_request = LinkChatRequest()
+        link_chat_request.http_method = HttpMethod.POST
+        link_chat_request.uri = "/open-apis/im/v1/chats/:chat_id/link"
+        link_chat_request.token_types = {AccessTokenType.TENANT, AccessTokenType.USER}
+        self._link_chat_request: LinkChatRequest = link_chat_request
+
+    def chat_id(self, chat_id: str) -> "LinkChatRequestBuilder":
+        self._link_chat_request.chat_id = chat_id
+        self._link_chat_request.paths["chat_id"] = str(chat_id)
+        return self
+
+    def request_body(self, request_body: LinkChatRequestBody) -> "LinkChatRequestBuilder":
+        self._link_chat_request.request_body = request_body
+        self._link_chat_request.body = request_body
+        return self
+
+    def build(self) -> LinkChatRequest:
+        return self._link_chat_request
diff --git a/lark_channel/api/im/v1/model/link_chat_request_body.py b/lark_channel/api/im/v1/model/link_chat_request_body.py
new file mode 100644
index 0000000..d100b91
--- /dev/null
+++ b/lark_channel/api/im/v1/model/link_chat_request_body.py
@@ -0,0 +1,28 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class LinkChatRequestBody(object):
+    _types = {
+        "validity_period": str,
+    }
+
+    def __init__(self, d=None):
+        self.validity_period: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "LinkChatRequestBodyBuilder":
+        return LinkChatRequestBodyBuilder()
+
+
+class LinkChatRequestBodyBuilder(object):
+    def __init__(self) -> None:
+        self._link_chat_request_body = LinkChatRequestBody()
+
+    def validity_period(self, validity_period: str) -> "LinkChatRequestBodyBuilder":
+        self._link_chat_request_body.validity_period = validity_period
+        return self
+
+    def build(self) -> "LinkChatRequestBody":
+        return self._link_chat_request_body
diff --git a/lark_channel/api/im/v1/model/link_chat_response.py b/lark_channel/api/im/v1/model/link_chat_response.py
new file mode 100644
index 0000000..f361dcc
--- /dev/null
+++ b/lark_channel/api/im/v1/model/link_chat_response.py
@@ -0,0 +1,15 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+from .link_chat_response_body import LinkChatResponseBody
+
+
+class LinkChatResponse(BaseResponse):
+    _types = {
+        "data": LinkChatResponseBody
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.data: Optional[LinkChatResponseBody] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/link_chat_response_body.py b/lark_channel/api/im/v1/model/link_chat_response_body.py
new file mode 100644
index 0000000..310089c
--- /dev/null
+++ b/lark_channel/api/im/v1/model/link_chat_response_body.py
@@ -0,0 +1,40 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class LinkChatResponseBody(object):
+    _types = {
+        "share_link": str,
+        "expire_time": str,
+        "is_permanent": bool,
+    }
+
+    def __init__(self, d=None):
+        self.share_link: Optional[str] = None
+        self.expire_time: Optional[str] = None
+        self.is_permanent: Optional[bool] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "LinkChatResponseBodyBuilder":
+        return LinkChatResponseBodyBuilder()
+
+
+class LinkChatResponseBodyBuilder(object):
+    def __init__(self) -> None:
+        self._link_chat_response_body = LinkChatResponseBody()
+
+    def share_link(self, share_link: str) -> "LinkChatResponseBodyBuilder":
+        self._link_chat_response_body.share_link = share_link
+        return self
+
+    def expire_time(self, expire_time: str) -> "LinkChatResponseBodyBuilder":
+        self._link_chat_response_body.expire_time = expire_time
+        return self
+
+    def is_permanent(self, is_permanent: bool) -> "LinkChatResponseBodyBuilder":
+        self._link_chat_response_body.is_permanent = is_permanent
+        return self
+
+    def build(self) -> "LinkChatResponseBody":
+        return self._link_chat_response_body
diff --git a/lark_channel/api/im/v1/model/list_chat.py b/lark_channel/api/im/v1/model/list_chat.py
new file mode 100644
index 0000000..13139d9
--- /dev/null
+++ b/lark_channel/api/im/v1/model/list_chat.py
@@ -0,0 +1,82 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class ListChat(object):
+    _types = {
+        "chat_id": str,
+        "avatar": str,
+        "name": str,
+        "description": str,
+        "owner_id": str,
+        "owner_id_type": str,
+        "external": bool,
+        "tenant_key": str,
+        "labels": List[str],
+        "chat_status": str,
+    }
+
+    def __init__(self, d=None):
+        self.chat_id: Optional[str] = None
+        self.avatar: Optional[str] = None
+        self.name: Optional[str] = None
+        self.description: Optional[str] = None
+        self.owner_id: Optional[str] = None
+        self.owner_id_type: Optional[str] = None
+        self.external: Optional[bool] = None
+        self.tenant_key: Optional[str] = None
+        self.labels: Optional[List[str]] = None
+        self.chat_status: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "ListChatBuilder":
+        return ListChatBuilder()
+
+
+class ListChatBuilder(object):
+    def __init__(self) -> None:
+        self._list_chat = ListChat()
+
+    def chat_id(self, chat_id: str) -> "ListChatBuilder":
+        self._list_chat.chat_id = chat_id
+        return self
+
+    def avatar(self, avatar: str) -> "ListChatBuilder":
+        self._list_chat.avatar = avatar
+        return self
+
+    def name(self, name: str) -> "ListChatBuilder":
+        self._list_chat.name = name
+        return self
+
+    def description(self, description: str) -> "ListChatBuilder":
+        self._list_chat.description = description
+        return self
+
+    def owner_id(self, owner_id: str) -> "ListChatBuilder":
+        self._list_chat.owner_id = owner_id
+        return self
+
+    def owner_id_type(self, owner_id_type: str) -> "ListChatBuilder":
+        self._list_chat.owner_id_type = owner_id_type
+        return self
+
+    def external(self, external: bool) -> "ListChatBuilder":
+        self._list_chat.external = external
+        return self
+
+    def tenant_key(self, tenant_key: str) -> "ListChatBuilder":
+        self._list_chat.tenant_key = tenant_key
+        return self
+
+    def labels(self, labels: List[str]) -> "ListChatBuilder":
+        self._list_chat.labels = labels
+        return self
+
+    def chat_status(self, chat_status: str) -> "ListChatBuilder":
+        self._list_chat.chat_status = chat_status
+        return self
+
+    def build(self) -> "ListChat":
+        return self._list_chat
diff --git a/lark_channel/api/im/v1/model/list_chat_request.py b/lark_channel/api/im/v1/model/list_chat_request.py
new file mode 100644
index 0000000..bb524bc
--- /dev/null
+++ b/lark_channel/api/im/v1/model/list_chat_request.py
@@ -0,0 +1,49 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+
+
+class ListChatRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.user_id_type: Optional[str] = None
+        self.sort_type: Optional[str] = None
+        self.page_token: Optional[str] = None
+        self.page_size: Optional[int] = None
+
+    @staticmethod
+    def builder() -> "ListChatRequestBuilder":
+        return ListChatRequestBuilder()
+
+
+class ListChatRequestBuilder(object):
+
+    def __init__(self) -> None:
+        list_chat_request = ListChatRequest()
+        list_chat_request.http_method = HttpMethod.GET
+        list_chat_request.uri = "/open-apis/im/v1/chats"
+        list_chat_request.token_types = {AccessTokenType.USER, AccessTokenType.TENANT}
+        self._list_chat_request: ListChatRequest = list_chat_request
+
+    def user_id_type(self, user_id_type: str) -> "ListChatRequestBuilder":
+        self._list_chat_request.user_id_type = user_id_type
+        self._list_chat_request.add_query("user_id_type", user_id_type)
+        return self
+
+    def sort_type(self, sort_type: str) -> "ListChatRequestBuilder":
+        self._list_chat_request.sort_type = sort_type
+        self._list_chat_request.add_query("sort_type", sort_type)
+        return self
+
+    def page_token(self, page_token: str) -> "ListChatRequestBuilder":
+        self._list_chat_request.page_token = page_token
+        self._list_chat_request.add_query("page_token", page_token)
+        return self
+
+    def page_size(self, page_size: int) -> "ListChatRequestBuilder":
+        self._list_chat_request.page_size = page_size
+        self._list_chat_request.add_query("page_size", page_size)
+        return self
+
+    def build(self) -> ListChatRequest:
+        return self._list_chat_request
diff --git a/lark_channel/api/im/v1/model/list_chat_response.py b/lark_channel/api/im/v1/model/list_chat_response.py
new file mode 100644
index 0000000..e830b47
--- /dev/null
+++ b/lark_channel/api/im/v1/model/list_chat_response.py
@@ -0,0 +1,15 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+from .list_chat_response_body import ListChatResponseBody
+
+
+class ListChatResponse(BaseResponse):
+    _types = {
+        "data": ListChatResponseBody
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.data: Optional[ListChatResponseBody] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/list_chat_response_body.py b/lark_channel/api/im/v1/model/list_chat_response_body.py
new file mode 100644
index 0000000..6c564bc
--- /dev/null
+++ b/lark_channel/api/im/v1/model/list_chat_response_body.py
@@ -0,0 +1,41 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .list_chat import ListChat
+
+
+class ListChatResponseBody(object):
+    _types = {
+        "items": List[ListChat],
+        "page_token": str,
+        "has_more": bool,
+    }
+
+    def __init__(self, d=None):
+        self.items: Optional[List[ListChat]] = None
+        self.page_token: Optional[str] = None
+        self.has_more: Optional[bool] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "ListChatResponseBodyBuilder":
+        return ListChatResponseBodyBuilder()
+
+
+class ListChatResponseBodyBuilder(object):
+    def __init__(self) -> None:
+        self._list_chat_response_body = ListChatResponseBody()
+
+    def items(self, items: List[ListChat]) -> "ListChatResponseBodyBuilder":
+        self._list_chat_response_body.items = items
+        return self
+
+    def page_token(self, page_token: str) -> "ListChatResponseBodyBuilder":
+        self._list_chat_response_body.page_token = page_token
+        return self
+
+    def has_more(self, has_more: bool) -> "ListChatResponseBodyBuilder":
+        self._list_chat_response_body.has_more = has_more
+        return self
+
+    def build(self) -> "ListChatResponseBody":
+        return self._list_chat_response_body
diff --git a/lark_channel/api/im/v1/model/list_event_moderator.py b/lark_channel/api/im/v1/model/list_event_moderator.py
new file mode 100644
index 0000000..07df8a0
--- /dev/null
+++ b/lark_channel/api/im/v1/model/list_event_moderator.py
@@ -0,0 +1,35 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .user_id import UserId
+
+
+class ListEventModerator(object):
+    _types = {
+        "tenant_key": str,
+        "user_id": UserId,
+    }
+
+    def __init__(self, d=None):
+        self.tenant_key: Optional[str] = None
+        self.user_id: Optional[UserId] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "ListEventModeratorBuilder":
+        return ListEventModeratorBuilder()
+
+
+class ListEventModeratorBuilder(object):
+    def __init__(self) -> None:
+        self._list_event_moderator = ListEventModerator()
+
+    def tenant_key(self, tenant_key: str) -> "ListEventModeratorBuilder":
+        self._list_event_moderator.tenant_key = tenant_key
+        return self
+
+    def user_id(self, user_id: UserId) -> "ListEventModeratorBuilder":
+        self._list_event_moderator.user_id = user_id
+        return self
+
+    def build(self) -> "ListEventModerator":
+        return self._list_event_moderator
diff --git a/lark_channel/api/im/v1/model/list_message_reaction_request.py b/lark_channel/api/im/v1/model/list_message_reaction_request.py
new file mode 100644
index 0000000..5c021a9
--- /dev/null
+++ b/lark_channel/api/im/v1/model/list_message_reaction_request.py
@@ -0,0 +1,55 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+
+
+class ListMessageReactionRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.reaction_type: Optional[str] = None
+        self.page_token: Optional[str] = None
+        self.page_size: Optional[int] = None
+        self.user_id_type: Optional[str] = None
+        self.message_id: Optional[str] = None
+
+    @staticmethod
+    def builder() -> "ListMessageReactionRequestBuilder":
+        return ListMessageReactionRequestBuilder()
+
+
+class ListMessageReactionRequestBuilder(object):
+
+    def __init__(self) -> None:
+        list_message_reaction_request = ListMessageReactionRequest()
+        list_message_reaction_request.http_method = HttpMethod.GET
+        list_message_reaction_request.uri = "/open-apis/im/v1/messages/:message_id/reactions"
+        list_message_reaction_request.token_types = {AccessTokenType.USER, AccessTokenType.TENANT}
+        self._list_message_reaction_request: ListMessageReactionRequest = list_message_reaction_request
+
+    def reaction_type(self, reaction_type: str) -> "ListMessageReactionRequestBuilder":
+        self._list_message_reaction_request.reaction_type = reaction_type
+        self._list_message_reaction_request.add_query("reaction_type", reaction_type)
+        return self
+
+    def page_token(self, page_token: str) -> "ListMessageReactionRequestBuilder":
+        self._list_message_reaction_request.page_token = page_token
+        self._list_message_reaction_request.add_query("page_token", page_token)
+        return self
+
+    def page_size(self, page_size: int) -> "ListMessageReactionRequestBuilder":
+        self._list_message_reaction_request.page_size = page_size
+        self._list_message_reaction_request.add_query("page_size", page_size)
+        return self
+
+    def user_id_type(self, user_id_type: str) -> "ListMessageReactionRequestBuilder":
+        self._list_message_reaction_request.user_id_type = user_id_type
+        self._list_message_reaction_request.add_query("user_id_type", user_id_type)
+        return self
+
+    def message_id(self, message_id: str) -> "ListMessageReactionRequestBuilder":
+        self._list_message_reaction_request.message_id = message_id
+        self._list_message_reaction_request.paths["message_id"] = str(message_id)
+        return self
+
+    def build(self) -> ListMessageReactionRequest:
+        return self._list_message_reaction_request
diff --git a/lark_channel/api/im/v1/model/list_message_reaction_response.py b/lark_channel/api/im/v1/model/list_message_reaction_response.py
new file mode 100644
index 0000000..feaacd0
--- /dev/null
+++ b/lark_channel/api/im/v1/model/list_message_reaction_response.py
@@ -0,0 +1,15 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+from .list_message_reaction_response_body import ListMessageReactionResponseBody
+
+
+class ListMessageReactionResponse(BaseResponse):
+    _types = {
+        "data": ListMessageReactionResponseBody
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.data: Optional[ListMessageReactionResponseBody] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/list_message_reaction_response_body.py b/lark_channel/api/im/v1/model/list_message_reaction_response_body.py
new file mode 100644
index 0000000..c83fbd6
--- /dev/null
+++ b/lark_channel/api/im/v1/model/list_message_reaction_response_body.py
@@ -0,0 +1,41 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .message_reaction import MessageReaction
+
+
+class ListMessageReactionResponseBody(object):
+    _types = {
+        "items": List[MessageReaction],
+        "has_more": bool,
+        "page_token": str,
+    }
+
+    def __init__(self, d=None):
+        self.items: Optional[List[MessageReaction]] = None
+        self.has_more: Optional[bool] = None
+        self.page_token: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "ListMessageReactionResponseBodyBuilder":
+        return ListMessageReactionResponseBodyBuilder()
+
+
+class ListMessageReactionResponseBodyBuilder(object):
+    def __init__(self) -> None:
+        self._list_message_reaction_response_body = ListMessageReactionResponseBody()
+
+    def items(self, items: List[MessageReaction]) -> "ListMessageReactionResponseBodyBuilder":
+        self._list_message_reaction_response_body.items = items
+        return self
+
+    def has_more(self, has_more: bool) -> "ListMessageReactionResponseBodyBuilder":
+        self._list_message_reaction_response_body.has_more = has_more
+        return self
+
+    def page_token(self, page_token: str) -> "ListMessageReactionResponseBodyBuilder":
+        self._list_message_reaction_response_body.page_token = page_token
+        return self
+
+    def build(self) -> "ListMessageReactionResponseBody":
+        return self._list_message_reaction_response_body
diff --git a/lark_channel/api/im/v1/model/list_message_request.py b/lark_channel/api/im/v1/model/list_message_request.py
new file mode 100644
index 0000000..012cfce
--- /dev/null
+++ b/lark_channel/api/im/v1/model/list_message_request.py
@@ -0,0 +1,67 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+
+
+class ListMessageRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.container_id_type: Optional[str] = None
+        self.container_id: Optional[str] = None
+        self.start_time: Optional[str] = None
+        self.end_time: Optional[str] = None
+        self.sort_type: Optional[str] = None
+        self.page_size: Optional[int] = None
+        self.page_token: Optional[str] = None
+
+    @staticmethod
+    def builder() -> "ListMessageRequestBuilder":
+        return ListMessageRequestBuilder()
+
+
+class ListMessageRequestBuilder(object):
+
+    def __init__(self) -> None:
+        list_message_request = ListMessageRequest()
+        list_message_request.http_method = HttpMethod.GET
+        list_message_request.uri = "/open-apis/im/v1/messages"
+        list_message_request.token_types = {AccessTokenType.TENANT}
+        self._list_message_request: ListMessageRequest = list_message_request
+
+    def container_id_type(self, container_id_type: str) -> "ListMessageRequestBuilder":
+        self._list_message_request.container_id_type = container_id_type
+        self._list_message_request.add_query("container_id_type", container_id_type)
+        return self
+
+    def container_id(self, container_id: str) -> "ListMessageRequestBuilder":
+        self._list_message_request.container_id = container_id
+        self._list_message_request.add_query("container_id", container_id)
+        return self
+
+    def start_time(self, start_time: str) -> "ListMessageRequestBuilder":
+        self._list_message_request.start_time = start_time
+        self._list_message_request.add_query("start_time", start_time)
+        return self
+
+    def end_time(self, end_time: str) -> "ListMessageRequestBuilder":
+        self._list_message_request.end_time = end_time
+        self._list_message_request.add_query("end_time", end_time)
+        return self
+
+    def sort_type(self, sort_type: str) -> "ListMessageRequestBuilder":
+        self._list_message_request.sort_type = sort_type
+        self._list_message_request.add_query("sort_type", sort_type)
+        return self
+
+    def page_size(self, page_size: int) -> "ListMessageRequestBuilder":
+        self._list_message_request.page_size = page_size
+        self._list_message_request.add_query("page_size", page_size)
+        return self
+
+    def page_token(self, page_token: str) -> "ListMessageRequestBuilder":
+        self._list_message_request.page_token = page_token
+        self._list_message_request.add_query("page_token", page_token)
+        return self
+
+    def build(self) -> ListMessageRequest:
+        return self._list_message_request
diff --git a/lark_channel/api/im/v1/model/list_message_response.py b/lark_channel/api/im/v1/model/list_message_response.py
new file mode 100644
index 0000000..214213d
--- /dev/null
+++ b/lark_channel/api/im/v1/model/list_message_response.py
@@ -0,0 +1,15 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+from .list_message_response_body import ListMessageResponseBody
+
+
+class ListMessageResponse(BaseResponse):
+    _types = {
+        "data": ListMessageResponseBody
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.data: Optional[ListMessageResponseBody] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/list_message_response_body.py b/lark_channel/api/im/v1/model/list_message_response_body.py
new file mode 100644
index 0000000..e45e975
--- /dev/null
+++ b/lark_channel/api/im/v1/model/list_message_response_body.py
@@ -0,0 +1,41 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .message import Message
+
+
+class ListMessageResponseBody(object):
+    _types = {
+        "has_more": bool,
+        "page_token": str,
+        "items": List[Message],
+    }
+
+    def __init__(self, d=None):
+        self.has_more: Optional[bool] = None
+        self.page_token: Optional[str] = None
+        self.items: Optional[List[Message]] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "ListMessageResponseBodyBuilder":
+        return ListMessageResponseBodyBuilder()
+
+
+class ListMessageResponseBodyBuilder(object):
+    def __init__(self) -> None:
+        self._list_message_response_body = ListMessageResponseBody()
+
+    def has_more(self, has_more: bool) -> "ListMessageResponseBodyBuilder":
+        self._list_message_response_body.has_more = has_more
+        return self
+
+    def page_token(self, page_token: str) -> "ListMessageResponseBodyBuilder":
+        self._list_message_response_body.page_token = page_token
+        return self
+
+    def items(self, items: List[Message]) -> "ListMessageResponseBodyBuilder":
+        self._list_message_response_body.items = items
+        return self
+
+    def build(self) -> "ListMessageResponseBody":
+        return self._list_message_response_body
diff --git a/lark_channel/api/im/v1/model/mention.py b/lark_channel/api/im/v1/model/mention.py
new file mode 100644
index 0000000..c0302c0
--- /dev/null
+++ b/lark_channel/api/im/v1/model/mention.py
@@ -0,0 +1,52 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class Mention(object):
+    _types = {
+        "key": str,
+        "id": str,
+        "id_type": str,
+        "name": str,
+        "tenant_key": str,
+    }
+
+    def __init__(self, d=None):
+        self.key: Optional[str] = None
+        self.id: Optional[str] = None
+        self.id_type: Optional[str] = None
+        self.name: Optional[str] = None
+        self.tenant_key: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "MentionBuilder":
+        return MentionBuilder()
+
+
+class MentionBuilder(object):
+    def __init__(self) -> None:
+        self._mention = Mention()
+
+    def key(self, key: str) -> "MentionBuilder":
+        self._mention.key = key
+        return self
+
+    def id(self, id: str) -> "MentionBuilder":
+        self._mention.id = id
+        return self
+
+    def id_type(self, id_type: str) -> "MentionBuilder":
+        self._mention.id_type = id_type
+        return self
+
+    def name(self, name: str) -> "MentionBuilder":
+        self._mention.name = name
+        return self
+
+    def tenant_key(self, tenant_key: str) -> "MentionBuilder":
+        self._mention.tenant_key = tenant_key
+        return self
+
+    def build(self) -> "Mention":
+        return self._mention
diff --git a/lark_channel/api/im/v1/model/mention_event.py b/lark_channel/api/im/v1/model/mention_event.py
new file mode 100644
index 0000000..eb4555a
--- /dev/null
+++ b/lark_channel/api/im/v1/model/mention_event.py
@@ -0,0 +1,47 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .user_id import UserId
+
+
+class MentionEvent(object):
+    _types = {
+        "key": str,
+        "id": UserId,
+        "name": str,
+        "tenant_key": str,
+    }
+
+    def __init__(self, d=None):
+        self.key: Optional[str] = None
+        self.id: Optional[UserId] = None
+        self.name: Optional[str] = None
+        self.tenant_key: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "MentionEventBuilder":
+        return MentionEventBuilder()
+
+
+class MentionEventBuilder(object):
+    def __init__(self) -> None:
+        self._mention_event = MentionEvent()
+
+    def key(self, key: str) -> "MentionEventBuilder":
+        self._mention_event.key = key
+        return self
+
+    def id(self, id: UserId) -> "MentionEventBuilder":
+        self._mention_event.id = id
+        return self
+
+    def name(self, name: str) -> "MentionEventBuilder":
+        self._mention_event.name = name
+        return self
+
+    def tenant_key(self, tenant_key: str) -> "MentionEventBuilder":
+        self._mention_event.tenant_key = tenant_key
+        return self
+
+    def build(self) -> "MentionEvent":
+        return self._mention_event
diff --git a/lark_channel/api/im/v1/model/merge_forward_message_request.py b/lark_channel/api/im/v1/model/merge_forward_message_request.py
new file mode 100644
index 0000000..33b9fb7
--- /dev/null
+++ b/lark_channel/api/im/v1/model/merge_forward_message_request.py
@@ -0,0 +1,44 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .merge_forward_message_request_body import MergeForwardMessageRequestBody
+
+
+class MergeForwardMessageRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.receive_id_type: Optional[str] = None
+        self.uuid: Optional[str] = None
+        self.request_body: Optional[MergeForwardMessageRequestBody] = None
+
+    @staticmethod
+    def builder() -> "MergeForwardMessageRequestBuilder":
+        return MergeForwardMessageRequestBuilder()
+
+
+class MergeForwardMessageRequestBuilder(object):
+
+    def __init__(self) -> None:
+        merge_forward_message_request = MergeForwardMessageRequest()
+        merge_forward_message_request.http_method = HttpMethod.POST
+        merge_forward_message_request.uri = "/open-apis/im/v1/messages/merge_forward"
+        merge_forward_message_request.token_types = {AccessTokenType.TENANT}
+        self._merge_forward_message_request: MergeForwardMessageRequest = merge_forward_message_request
+
+    def receive_id_type(self, receive_id_type: str) -> "MergeForwardMessageRequestBuilder":
+        self._merge_forward_message_request.receive_id_type = receive_id_type
+        self._merge_forward_message_request.add_query("receive_id_type", receive_id_type)
+        return self
+
+    def uuid(self, uuid: str) -> "MergeForwardMessageRequestBuilder":
+        self._merge_forward_message_request.uuid = uuid
+        self._merge_forward_message_request.add_query("uuid", uuid)
+        return self
+
+    def request_body(self, request_body: MergeForwardMessageRequestBody) -> "MergeForwardMessageRequestBuilder":
+        self._merge_forward_message_request.request_body = request_body
+        self._merge_forward_message_request.body = request_body
+        return self
+
+    def build(self) -> MergeForwardMessageRequest:
+        return self._merge_forward_message_request
diff --git a/lark_channel/api/im/v1/model/merge_forward_message_request_body.py b/lark_channel/api/im/v1/model/merge_forward_message_request_body.py
new file mode 100644
index 0000000..619f52b
--- /dev/null
+++ b/lark_channel/api/im/v1/model/merge_forward_message_request_body.py
@@ -0,0 +1,34 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class MergeForwardMessageRequestBody(object):
+    _types = {
+        "receive_id": str,
+        "message_id_list": List[str],
+    }
+
+    def __init__(self, d=None):
+        self.receive_id: Optional[str] = None
+        self.message_id_list: Optional[List[str]] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "MergeForwardMessageRequestBodyBuilder":
+        return MergeForwardMessageRequestBodyBuilder()
+
+
+class MergeForwardMessageRequestBodyBuilder(object):
+    def __init__(self) -> None:
+        self._merge_forward_message_request_body = MergeForwardMessageRequestBody()
+
+    def receive_id(self, receive_id: str) -> "MergeForwardMessageRequestBodyBuilder":
+        self._merge_forward_message_request_body.receive_id = receive_id
+        return self
+
+    def message_id_list(self, message_id_list: List[str]) -> "MergeForwardMessageRequestBodyBuilder":
+        self._merge_forward_message_request_body.message_id_list = message_id_list
+        return self
+
+    def build(self) -> "MergeForwardMessageRequestBody":
+        return self._merge_forward_message_request_body
diff --git a/lark_channel/api/im/v1/model/merge_forward_message_response.py b/lark_channel/api/im/v1/model/merge_forward_message_response.py
new file mode 100644
index 0000000..748d44a
--- /dev/null
+++ b/lark_channel/api/im/v1/model/merge_forward_message_response.py
@@ -0,0 +1,15 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+from .merge_forward_message_response_body import MergeForwardMessageResponseBody
+
+
+class MergeForwardMessageResponse(BaseResponse):
+    _types = {
+        "data": MergeForwardMessageResponseBody
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.data: Optional[MergeForwardMessageResponseBody] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/merge_forward_message_response_body.py b/lark_channel/api/im/v1/model/merge_forward_message_response_body.py
new file mode 100644
index 0000000..92dc074
--- /dev/null
+++ b/lark_channel/api/im/v1/model/merge_forward_message_response_body.py
@@ -0,0 +1,35 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .message import Message
+
+
+class MergeForwardMessageResponseBody(object):
+    _types = {
+        "message": Message,
+        "invalid_message_id_list": List[str],
+    }
+
+    def __init__(self, d=None):
+        self.message: Optional[Message] = None
+        self.invalid_message_id_list: Optional[List[str]] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "MergeForwardMessageResponseBodyBuilder":
+        return MergeForwardMessageResponseBodyBuilder()
+
+
+class MergeForwardMessageResponseBodyBuilder(object):
+    def __init__(self) -> None:
+        self._merge_forward_message_response_body = MergeForwardMessageResponseBody()
+
+    def message(self, message: Message) -> "MergeForwardMessageResponseBodyBuilder":
+        self._merge_forward_message_response_body.message = message
+        return self
+
+    def invalid_message_id_list(self, invalid_message_id_list: List[str]) -> "MergeForwardMessageResponseBodyBuilder":
+        self._merge_forward_message_response_body.invalid_message_id_list = invalid_message_id_list
+        return self
+
+    def build(self) -> "MergeForwardMessageResponseBody":
+        return self._merge_forward_message_response_body
diff --git a/lark_channel/api/im/v1/model/message.py b/lark_channel/api/im/v1/model/message.py
new file mode 100644
index 0000000..cbb0501
--- /dev/null
+++ b/lark_channel/api/im/v1/model/message.py
@@ -0,0 +1,109 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .sender import Sender
+from .message_body import MessageBody
+from .mention import Mention
+
+
+class Message(object):
+    _types = {
+        "message_id": str,
+        "root_id": str,
+        "parent_id": str,
+        "thread_id": str,
+        "msg_type": str,
+        "create_time": int,
+        "update_time": int,
+        "deleted": bool,
+        "updated": bool,
+        "chat_id": str,
+        "sender": Sender,
+        "body": MessageBody,
+        "mentions": List[Mention],
+        "upper_message_id": str,
+    }
+
+    def __init__(self, d=None):
+        self.message_id: Optional[str] = None
+        self.root_id: Optional[str] = None
+        self.parent_id: Optional[str] = None
+        self.thread_id: Optional[str] = None
+        self.msg_type: Optional[str] = None
+        self.create_time: Optional[int] = None
+        self.update_time: Optional[int] = None
+        self.deleted: Optional[bool] = None
+        self.updated: Optional[bool] = None
+        self.chat_id: Optional[str] = None
+        self.sender: Optional[Sender] = None
+        self.body: Optional[MessageBody] = None
+        self.mentions: Optional[List[Mention]] = None
+        self.upper_message_id: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "MessageBuilder":
+        return MessageBuilder()
+
+
+class MessageBuilder(object):
+    def __init__(self) -> None:
+        self._message = Message()
+
+    def message_id(self, message_id: str) -> "MessageBuilder":
+        self._message.message_id = message_id
+        return self
+
+    def root_id(self, root_id: str) -> "MessageBuilder":
+        self._message.root_id = root_id
+        return self
+
+    def parent_id(self, parent_id: str) -> "MessageBuilder":
+        self._message.parent_id = parent_id
+        return self
+
+    def thread_id(self, thread_id: str) -> "MessageBuilder":
+        self._message.thread_id = thread_id
+        return self
+
+    def msg_type(self, msg_type: str) -> "MessageBuilder":
+        self._message.msg_type = msg_type
+        return self
+
+    def create_time(self, create_time: int) -> "MessageBuilder":
+        self._message.create_time = create_time
+        return self
+
+    def update_time(self, update_time: int) -> "MessageBuilder":
+        self._message.update_time = update_time
+        return self
+
+    def deleted(self, deleted: bool) -> "MessageBuilder":
+        self._message.deleted = deleted
+        return self
+
+    def updated(self, updated: bool) -> "MessageBuilder":
+        self._message.updated = updated
+        return self
+
+    def chat_id(self, chat_id: str) -> "MessageBuilder":
+        self._message.chat_id = chat_id
+        return self
+
+    def sender(self, sender: Sender) -> "MessageBuilder":
+        self._message.sender = sender
+        return self
+
+    def body(self, body: MessageBody) -> "MessageBuilder":
+        self._message.body = body
+        return self
+
+    def mentions(self, mentions: List[Mention]) -> "MessageBuilder":
+        self._message.mentions = mentions
+        return self
+
+    def upper_message_id(self, upper_message_id: str) -> "MessageBuilder":
+        self._message.upper_message_id = upper_message_id
+        return self
+
+    def build(self) -> "Message":
+        return self._message
diff --git a/lark_channel/api/im/v1/model/message_body.py b/lark_channel/api/im/v1/model/message_body.py
new file mode 100644
index 0000000..bc07119
--- /dev/null
+++ b/lark_channel/api/im/v1/model/message_body.py
@@ -0,0 +1,28 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class MessageBody(object):
+    _types = {
+        "content": str,
+    }
+
+    def __init__(self, d=None):
+        self.content: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "MessageBodyBuilder":
+        return MessageBodyBuilder()
+
+
+class MessageBodyBuilder(object):
+    def __init__(self) -> None:
+        self._message_body = MessageBody()
+
+    def content(self, content: str) -> "MessageBodyBuilder":
+        self._message_body.content = content
+        return self
+
+    def build(self) -> "MessageBody":
+        return self._message_body
diff --git a/lark_channel/api/im/v1/model/message_reaction.py b/lark_channel/api/im/v1/model/message_reaction.py
new file mode 100644
index 0000000..662a661
--- /dev/null
+++ b/lark_channel/api/im/v1/model/message_reaction.py
@@ -0,0 +1,48 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .operator import Operator
+from .emoji import Emoji
+
+
+class MessageReaction(object):
+    _types = {
+        "reaction_id": str,
+        "operator": Operator,
+        "action_time": int,
+        "reaction_type": Emoji,
+    }
+
+    def __init__(self, d=None):
+        self.reaction_id: Optional[str] = None
+        self.operator: Optional[Operator] = None
+        self.action_time: Optional[int] = None
+        self.reaction_type: Optional[Emoji] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "MessageReactionBuilder":
+        return MessageReactionBuilder()
+
+
+class MessageReactionBuilder(object):
+    def __init__(self) -> None:
+        self._message_reaction = MessageReaction()
+
+    def reaction_id(self, reaction_id: str) -> "MessageReactionBuilder":
+        self._message_reaction.reaction_id = reaction_id
+        return self
+
+    def operator(self, operator: Operator) -> "MessageReactionBuilder":
+        self._message_reaction.operator = operator
+        return self
+
+    def action_time(self, action_time: int) -> "MessageReactionBuilder":
+        self._message_reaction.action_time = action_time
+        return self
+
+    def reaction_type(self, reaction_type: Emoji) -> "MessageReactionBuilder":
+        self._message_reaction.reaction_type = reaction_type
+        return self
+
+    def build(self) -> "MessageReaction":
+        return self._message_reaction
diff --git a/lark_channel/api/im/v1/model/moderator_list.py b/lark_channel/api/im/v1/model/moderator_list.py
new file mode 100644
index 0000000..fa4ba4c
--- /dev/null
+++ b/lark_channel/api/im/v1/model/moderator_list.py
@@ -0,0 +1,36 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .list_event_moderator import ListEventModerator
+from .list_event_moderator import ListEventModerator
+
+
+class ModeratorList(object):
+    _types = {
+        "added_member_list": List[ListEventModerator],
+        "removed_member_list": List[ListEventModerator],
+    }
+
+    def __init__(self, d=None):
+        self.added_member_list: Optional[List[ListEventModerator]] = None
+        self.removed_member_list: Optional[List[ListEventModerator]] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "ModeratorListBuilder":
+        return ModeratorListBuilder()
+
+
+class ModeratorListBuilder(object):
+    def __init__(self) -> None:
+        self._moderator_list = ModeratorList()
+
+    def added_member_list(self, added_member_list: List[ListEventModerator]) -> "ModeratorListBuilder":
+        self._moderator_list.added_member_list = added_member_list
+        return self
+
+    def removed_member_list(self, removed_member_list: List[ListEventModerator]) -> "ModeratorListBuilder":
+        self._moderator_list.removed_member_list = removed_member_list
+        return self
+
+    def build(self) -> "ModeratorList":
+        return self._moderator_list
diff --git a/lark_channel/api/im/v1/model/operator.py b/lark_channel/api/im/v1/model/operator.py
new file mode 100644
index 0000000..a728996
--- /dev/null
+++ b/lark_channel/api/im/v1/model/operator.py
@@ -0,0 +1,34 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class Operator(object):
+    _types = {
+        "operator_id": str,
+        "operator_type": str,
+    }
+
+    def __init__(self, d=None):
+        self.operator_id: Optional[str] = None
+        self.operator_type: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "OperatorBuilder":
+        return OperatorBuilder()
+
+
+class OperatorBuilder(object):
+    def __init__(self) -> None:
+        self._operator = Operator()
+
+    def operator_id(self, operator_id: str) -> "OperatorBuilder":
+        self._operator.operator_id = operator_id
+        return self
+
+    def operator_type(self, operator_type: str) -> "OperatorBuilder":
+        self._operator.operator_type = operator_type
+        return self
+
+    def build(self) -> "Operator":
+        return self._operator
diff --git a/lark_channel/api/im/v1/model/p2_im_chat_access_event_bot_p2p_chat_entered_v1.py b/lark_channel/api/im/v1/model/p2_im_chat_access_event_bot_p2p_chat_entered_v1.py
new file mode 100644
index 0000000..db9a399
--- /dev/null
+++ b/lark_channel/api/im/v1/model/p2_im_chat_access_event_bot_p2p_chat_entered_v1.py
@@ -0,0 +1,32 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.event.context import EventContext
+from .user_id import UserId
+
+
+class P2ImChatAccessEventBotP2pChatEnteredV1Data(object):
+    _types = {
+        "chat_id": str,
+        "operator_id": UserId,
+        "last_message_id": str,
+        "last_message_create_time": str,
+    }
+
+    def __init__(self, d=None):
+        self.chat_id: Optional[str] = None
+        self.operator_id: Optional[UserId] = None
+        self.last_message_id: Optional[str] = None
+        self.last_message_create_time: Optional[str] = None
+        init(self, d, self._types)
+
+
+class P2ImChatAccessEventBotP2pChatEnteredV1(EventContext):
+    _types = {
+        "event": P2ImChatAccessEventBotP2pChatEnteredV1Data
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self._types.update(super()._types)
+        self.event: Optional[P2ImChatAccessEventBotP2pChatEnteredV1Data] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/p2_im_chat_disbanded_v1.py b/lark_channel/api/im/v1/model/p2_im_chat_disbanded_v1.py
new file mode 100644
index 0000000..3af421e
--- /dev/null
+++ b/lark_channel/api/im/v1/model/p2_im_chat_disbanded_v1.py
@@ -0,0 +1,37 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.event.context import EventContext
+from .user_id import UserId
+from .i18n_names import I18nNames
+
+
+class P2ImChatDisbandedV1Data(object):
+    _types = {
+        "chat_id": str,
+        "operator_id": UserId,
+        "external": bool,
+        "operator_tenant_key": str,
+        "name": str,
+        "i18n_names": I18nNames,
+    }
+
+    def __init__(self, d=None):
+        self.chat_id: Optional[str] = None
+        self.operator_id: Optional[UserId] = None
+        self.external: Optional[bool] = None
+        self.operator_tenant_key: Optional[str] = None
+        self.name: Optional[str] = None
+        self.i18n_names: Optional[I18nNames] = None
+        init(self, d, self._types)
+
+
+class P2ImChatDisbandedV1(EventContext):
+    _types = {
+        "event": P2ImChatDisbandedV1Data
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self._types.update(super()._types)
+        self.event: Optional[P2ImChatDisbandedV1Data] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/p2_im_chat_member_bot_added_v1.py b/lark_channel/api/im/v1/model/p2_im_chat_member_bot_added_v1.py
new file mode 100644
index 0000000..1f619db
--- /dev/null
+++ b/lark_channel/api/im/v1/model/p2_im_chat_member_bot_added_v1.py
@@ -0,0 +1,37 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.event.context import EventContext
+from .user_id import UserId
+from .i18n_names import I18nNames
+
+
+class P2ImChatMemberBotAddedV1Data(object):
+    _types = {
+        "chat_id": str,
+        "operator_id": UserId,
+        "external": bool,
+        "operator_tenant_key": str,
+        "name": str,
+        "i18n_names": I18nNames,
+    }
+
+    def __init__(self, d=None):
+        self.chat_id: Optional[str] = None
+        self.operator_id: Optional[UserId] = None
+        self.external: Optional[bool] = None
+        self.operator_tenant_key: Optional[str] = None
+        self.name: Optional[str] = None
+        self.i18n_names: Optional[I18nNames] = None
+        init(self, d, self._types)
+
+
+class P2ImChatMemberBotAddedV1(EventContext):
+    _types = {
+        "event": P2ImChatMemberBotAddedV1Data
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self._types.update(super()._types)
+        self.event: Optional[P2ImChatMemberBotAddedV1Data] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/p2_im_chat_member_bot_deleted_v1.py b/lark_channel/api/im/v1/model/p2_im_chat_member_bot_deleted_v1.py
new file mode 100644
index 0000000..718b76c
--- /dev/null
+++ b/lark_channel/api/im/v1/model/p2_im_chat_member_bot_deleted_v1.py
@@ -0,0 +1,37 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.event.context import EventContext
+from .user_id import UserId
+from .i18n_names import I18nNames
+
+
+class P2ImChatMemberBotDeletedV1Data(object):
+    _types = {
+        "chat_id": str,
+        "operator_id": UserId,
+        "external": bool,
+        "operator_tenant_key": str,
+        "name": str,
+        "i18n_names": I18nNames,
+    }
+
+    def __init__(self, d=None):
+        self.chat_id: Optional[str] = None
+        self.operator_id: Optional[UserId] = None
+        self.external: Optional[bool] = None
+        self.operator_tenant_key: Optional[str] = None
+        self.name: Optional[str] = None
+        self.i18n_names: Optional[I18nNames] = None
+        init(self, d, self._types)
+
+
+class P2ImChatMemberBotDeletedV1(EventContext):
+    _types = {
+        "event": P2ImChatMemberBotDeletedV1Data
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self._types.update(super()._types)
+        self.event: Optional[P2ImChatMemberBotDeletedV1Data] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/p2_im_chat_member_user_added_v1.py b/lark_channel/api/im/v1/model/p2_im_chat_member_user_added_v1.py
new file mode 100644
index 0000000..f908a94
--- /dev/null
+++ b/lark_channel/api/im/v1/model/p2_im_chat_member_user_added_v1.py
@@ -0,0 +1,40 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.event.context import EventContext
+from .user_id import UserId
+from .chat_member_user import ChatMemberUser
+from .i18n_names import I18nNames
+
+
+class P2ImChatMemberUserAddedV1Data(object):
+    _types = {
+        "chat_id": str,
+        "operator_id": UserId,
+        "external": bool,
+        "operator_tenant_key": str,
+        "users": List[ChatMemberUser],
+        "name": str,
+        "i18n_names": I18nNames,
+    }
+
+    def __init__(self, d=None):
+        self.chat_id: Optional[str] = None
+        self.operator_id: Optional[UserId] = None
+        self.external: Optional[bool] = None
+        self.operator_tenant_key: Optional[str] = None
+        self.users: Optional[List[ChatMemberUser]] = None
+        self.name: Optional[str] = None
+        self.i18n_names: Optional[I18nNames] = None
+        init(self, d, self._types)
+
+
+class P2ImChatMemberUserAddedV1(EventContext):
+    _types = {
+        "event": P2ImChatMemberUserAddedV1Data
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self._types.update(super()._types)
+        self.event: Optional[P2ImChatMemberUserAddedV1Data] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/p2_im_chat_member_user_deleted_v1.py b/lark_channel/api/im/v1/model/p2_im_chat_member_user_deleted_v1.py
new file mode 100644
index 0000000..df928d9
--- /dev/null
+++ b/lark_channel/api/im/v1/model/p2_im_chat_member_user_deleted_v1.py
@@ -0,0 +1,40 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.event.context import EventContext
+from .user_id import UserId
+from .chat_member_user import ChatMemberUser
+from .i18n_names import I18nNames
+
+
+class P2ImChatMemberUserDeletedV1Data(object):
+    _types = {
+        "chat_id": str,
+        "operator_id": UserId,
+        "external": bool,
+        "operator_tenant_key": str,
+        "users": List[ChatMemberUser],
+        "name": str,
+        "i18n_names": I18nNames,
+    }
+
+    def __init__(self, d=None):
+        self.chat_id: Optional[str] = None
+        self.operator_id: Optional[UserId] = None
+        self.external: Optional[bool] = None
+        self.operator_tenant_key: Optional[str] = None
+        self.users: Optional[List[ChatMemberUser]] = None
+        self.name: Optional[str] = None
+        self.i18n_names: Optional[I18nNames] = None
+        init(self, d, self._types)
+
+
+class P2ImChatMemberUserDeletedV1(EventContext):
+    _types = {
+        "event": P2ImChatMemberUserDeletedV1Data
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self._types.update(super()._types)
+        self.event: Optional[P2ImChatMemberUserDeletedV1Data] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/p2_im_chat_member_user_withdrawn_v1.py b/lark_channel/api/im/v1/model/p2_im_chat_member_user_withdrawn_v1.py
new file mode 100644
index 0000000..e3aac40
--- /dev/null
+++ b/lark_channel/api/im/v1/model/p2_im_chat_member_user_withdrawn_v1.py
@@ -0,0 +1,40 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.event.context import EventContext
+from .user_id import UserId
+from .chat_member_user import ChatMemberUser
+from .i18n_names import I18nNames
+
+
+class P2ImChatMemberUserWithdrawnV1Data(object):
+    _types = {
+        "chat_id": str,
+        "operator_id": UserId,
+        "external": bool,
+        "operator_tenant_key": str,
+        "users": List[ChatMemberUser],
+        "name": str,
+        "i18n_names": I18nNames,
+    }
+
+    def __init__(self, d=None):
+        self.chat_id: Optional[str] = None
+        self.operator_id: Optional[UserId] = None
+        self.external: Optional[bool] = None
+        self.operator_tenant_key: Optional[str] = None
+        self.users: Optional[List[ChatMemberUser]] = None
+        self.name: Optional[str] = None
+        self.i18n_names: Optional[I18nNames] = None
+        init(self, d, self._types)
+
+
+class P2ImChatMemberUserWithdrawnV1(EventContext):
+    _types = {
+        "event": P2ImChatMemberUserWithdrawnV1Data
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self._types.update(super()._types)
+        self.event: Optional[P2ImChatMemberUserWithdrawnV1Data] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/p2_im_chat_updated_v1.py b/lark_channel/api/im/v1/model/p2_im_chat_updated_v1.py
new file mode 100644
index 0000000..3cad90d
--- /dev/null
+++ b/lark_channel/api/im/v1/model/p2_im_chat_updated_v1.py
@@ -0,0 +1,41 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.event.context import EventContext
+from .user_id import UserId
+from .chat_change import ChatChange
+from .chat_change import ChatChange
+from .moderator_list import ModeratorList
+
+
+class P2ImChatUpdatedV1Data(object):
+    _types = {
+        "chat_id": str,
+        "operator_id": UserId,
+        "external": bool,
+        "operator_tenant_key": str,
+        "after_change": ChatChange,
+        "before_change": ChatChange,
+        "moderator_list": ModeratorList,
+    }
+
+    def __init__(self, d=None):
+        self.chat_id: Optional[str] = None
+        self.operator_id: Optional[UserId] = None
+        self.external: Optional[bool] = None
+        self.operator_tenant_key: Optional[str] = None
+        self.after_change: Optional[ChatChange] = None
+        self.before_change: Optional[ChatChange] = None
+        self.moderator_list: Optional[ModeratorList] = None
+        init(self, d, self._types)
+
+
+class P2ImChatUpdatedV1(EventContext):
+    _types = {
+        "event": P2ImChatUpdatedV1Data
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self._types.update(super()._types)
+        self.event: Optional[P2ImChatUpdatedV1Data] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/p2_im_message_message_read_v1.py b/lark_channel/api/im/v1/model/p2_im_message_message_read_v1.py
new file mode 100644
index 0000000..77d180b
--- /dev/null
+++ b/lark_channel/api/im/v1/model/p2_im_message_message_read_v1.py
@@ -0,0 +1,28 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.event.context import EventContext
+from .event_message_reader import EventMessageReader
+
+
+class P2ImMessageMessageReadV1Data(object):
+    _types = {
+        "reader": EventMessageReader,
+        "message_id_list": List[str],
+    }
+
+    def __init__(self, d=None):
+        self.reader: Optional[EventMessageReader] = None
+        self.message_id_list: Optional[List[str]] = None
+        init(self, d, self._types)
+
+
+class P2ImMessageMessageReadV1(EventContext):
+    _types = {
+        "event": P2ImMessageMessageReadV1Data
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self._types.update(super()._types)
+        self.event: Optional[P2ImMessageMessageReadV1Data] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/p2_im_message_reaction_created_v1.py b/lark_channel/api/im/v1/model/p2_im_message_reaction_created_v1.py
new file mode 100644
index 0000000..30961e2
--- /dev/null
+++ b/lark_channel/api/im/v1/model/p2_im_message_reaction_created_v1.py
@@ -0,0 +1,37 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.event.context import EventContext
+from .emoji import Emoji
+from .user_id import UserId
+
+
+class P2ImMessageReactionCreatedV1Data(object):
+    _types = {
+        "message_id": str,
+        "reaction_type": Emoji,
+        "operator_type": str,
+        "user_id": UserId,
+        "app_id": str,
+        "action_time": str,
+    }
+
+    def __init__(self, d=None):
+        self.message_id: Optional[str] = None
+        self.reaction_type: Optional[Emoji] = None
+        self.operator_type: Optional[str] = None
+        self.user_id: Optional[UserId] = None
+        self.app_id: Optional[str] = None
+        self.action_time: Optional[str] = None
+        init(self, d, self._types)
+
+
+class P2ImMessageReactionCreatedV1(EventContext):
+    _types = {
+        "event": P2ImMessageReactionCreatedV1Data
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self._types.update(super()._types)
+        self.event: Optional[P2ImMessageReactionCreatedV1Data] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/p2_im_message_reaction_deleted_v1.py b/lark_channel/api/im/v1/model/p2_im_message_reaction_deleted_v1.py
new file mode 100644
index 0000000..c895faf
--- /dev/null
+++ b/lark_channel/api/im/v1/model/p2_im_message_reaction_deleted_v1.py
@@ -0,0 +1,37 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.event.context import EventContext
+from .emoji import Emoji
+from .user_id import UserId
+
+
+class P2ImMessageReactionDeletedV1Data(object):
+    _types = {
+        "message_id": str,
+        "reaction_type": Emoji,
+        "operator_type": str,
+        "user_id": UserId,
+        "app_id": str,
+        "action_time": str,
+    }
+
+    def __init__(self, d=None):
+        self.message_id: Optional[str] = None
+        self.reaction_type: Optional[Emoji] = None
+        self.operator_type: Optional[str] = None
+        self.user_id: Optional[UserId] = None
+        self.app_id: Optional[str] = None
+        self.action_time: Optional[str] = None
+        init(self, d, self._types)
+
+
+class P2ImMessageReactionDeletedV1(EventContext):
+    _types = {
+        "event": P2ImMessageReactionDeletedV1Data
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self._types.update(super()._types)
+        self.event: Optional[P2ImMessageReactionDeletedV1Data] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/p2_im_message_recalled_v1.py b/lark_channel/api/im/v1/model/p2_im_message_recalled_v1.py
new file mode 100644
index 0000000..b47109c
--- /dev/null
+++ b/lark_channel/api/im/v1/model/p2_im_message_recalled_v1.py
@@ -0,0 +1,31 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.event.context import EventContext
+
+
+class P2ImMessageRecalledV1Data(object):
+    _types = {
+        "message_id": str,
+        "chat_id": str,
+        "recall_time": str,
+        "recall_type": str,
+    }
+
+    def __init__(self, d=None):
+        self.message_id: Optional[str] = None
+        self.chat_id: Optional[str] = None
+        self.recall_time: Optional[str] = None
+        self.recall_type: Optional[str] = None
+        init(self, d, self._types)
+
+
+class P2ImMessageRecalledV1(EventContext):
+    _types = {
+        "event": P2ImMessageRecalledV1Data
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self._types.update(super()._types)
+        self.event: Optional[P2ImMessageRecalledV1Data] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/p2_im_message_receive_v1.py b/lark_channel/api/im/v1/model/p2_im_message_receive_v1.py
new file mode 100644
index 0000000..a376b1d
--- /dev/null
+++ b/lark_channel/api/im/v1/model/p2_im_message_receive_v1.py
@@ -0,0 +1,29 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.event.context import EventContext
+from .event_sender import EventSender
+from .event_message import EventMessage
+
+
+class P2ImMessageReceiveV1Data(object):
+    _types = {
+        "sender": EventSender,
+        "message": EventMessage,
+    }
+
+    def __init__(self, d=None):
+        self.sender: Optional[EventSender] = None
+        self.message: Optional[EventMessage] = None
+        init(self, d, self._types)
+
+
+class P2ImMessageReceiveV1(EventContext):
+    _types = {
+        "event": P2ImMessageReceiveV1Data
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self._types.update(super()._types)
+        self.event: Optional[P2ImMessageReceiveV1Data] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/patch_message_request.py b/lark_channel/api/im/v1/model/patch_message_request.py
new file mode 100644
index 0000000..2d486fb
--- /dev/null
+++ b/lark_channel/api/im/v1/model/patch_message_request.py
@@ -0,0 +1,38 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .patch_message_request_body import PatchMessageRequestBody
+
+
+class PatchMessageRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.message_id: Optional[str] = None
+        self.request_body: Optional[PatchMessageRequestBody] = None
+
+    @staticmethod
+    def builder() -> "PatchMessageRequestBuilder":
+        return PatchMessageRequestBuilder()
+
+
+class PatchMessageRequestBuilder(object):
+
+    def __init__(self) -> None:
+        patch_message_request = PatchMessageRequest()
+        patch_message_request.http_method = HttpMethod.PATCH
+        patch_message_request.uri = "/open-apis/im/v1/messages/:message_id"
+        patch_message_request.token_types = {AccessTokenType.TENANT, AccessTokenType.USER}
+        self._patch_message_request: PatchMessageRequest = patch_message_request
+
+    def message_id(self, message_id: str) -> "PatchMessageRequestBuilder":
+        self._patch_message_request.message_id = message_id
+        self._patch_message_request.paths["message_id"] = str(message_id)
+        return self
+
+    def request_body(self, request_body: PatchMessageRequestBody) -> "PatchMessageRequestBuilder":
+        self._patch_message_request.request_body = request_body
+        self._patch_message_request.body = request_body
+        return self
+
+    def build(self) -> PatchMessageRequest:
+        return self._patch_message_request
diff --git a/lark_channel/api/im/v1/model/patch_message_request_body.py b/lark_channel/api/im/v1/model/patch_message_request_body.py
new file mode 100644
index 0000000..2cc017c
--- /dev/null
+++ b/lark_channel/api/im/v1/model/patch_message_request_body.py
@@ -0,0 +1,28 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class PatchMessageRequestBody(object):
+    _types = {
+        "content": str,
+    }
+
+    def __init__(self, d=None):
+        self.content: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "PatchMessageRequestBodyBuilder":
+        return PatchMessageRequestBodyBuilder()
+
+
+class PatchMessageRequestBodyBuilder(object):
+    def __init__(self) -> None:
+        self._patch_message_request_body = PatchMessageRequestBody()
+
+    def content(self, content: str) -> "PatchMessageRequestBodyBuilder":
+        self._patch_message_request_body.content = content
+        return self
+
+    def build(self) -> "PatchMessageRequestBody":
+        return self._patch_message_request_body
diff --git a/lark_channel/api/im/v1/model/patch_message_response.py b/lark_channel/api/im/v1/model/patch_message_response.py
new file mode 100644
index 0000000..ddba51a
--- /dev/null
+++ b/lark_channel/api/im/v1/model/patch_message_response.py
@@ -0,0 +1,14 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+
+
+class PatchMessageResponse(BaseResponse):
+    _types = {
+
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/push_follow_up_message_request.py b/lark_channel/api/im/v1/model/push_follow_up_message_request.py
new file mode 100644
index 0000000..a0f1c48
--- /dev/null
+++ b/lark_channel/api/im/v1/model/push_follow_up_message_request.py
@@ -0,0 +1,38 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .push_follow_up_message_request_body import PushFollowUpMessageRequestBody
+
+
+class PushFollowUpMessageRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.message_id: Optional[str] = None
+        self.request_body: Optional[PushFollowUpMessageRequestBody] = None
+
+    @staticmethod
+    def builder() -> "PushFollowUpMessageRequestBuilder":
+        return PushFollowUpMessageRequestBuilder()
+
+
+class PushFollowUpMessageRequestBuilder(object):
+
+    def __init__(self) -> None:
+        push_follow_up_message_request = PushFollowUpMessageRequest()
+        push_follow_up_message_request.http_method = HttpMethod.POST
+        push_follow_up_message_request.uri = "/open-apis/im/v1/messages/:message_id/push_follow_up"
+        push_follow_up_message_request.token_types = {AccessTokenType.TENANT}
+        self._push_follow_up_message_request: PushFollowUpMessageRequest = push_follow_up_message_request
+
+    def message_id(self, message_id: str) -> "PushFollowUpMessageRequestBuilder":
+        self._push_follow_up_message_request.message_id = message_id
+        self._push_follow_up_message_request.paths["message_id"] = str(message_id)
+        return self
+
+    def request_body(self, request_body: PushFollowUpMessageRequestBody) -> "PushFollowUpMessageRequestBuilder":
+        self._push_follow_up_message_request.request_body = request_body
+        self._push_follow_up_message_request.body = request_body
+        return self
+
+    def build(self) -> PushFollowUpMessageRequest:
+        return self._push_follow_up_message_request
diff --git a/lark_channel/api/im/v1/model/push_follow_up_message_request_body.py b/lark_channel/api/im/v1/model/push_follow_up_message_request_body.py
new file mode 100644
index 0000000..be50cc4
--- /dev/null
+++ b/lark_channel/api/im/v1/model/push_follow_up_message_request_body.py
@@ -0,0 +1,29 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .follow_up import FollowUp
+
+
+class PushFollowUpMessageRequestBody(object):
+    _types = {
+        "follow_ups": List[FollowUp],
+    }
+
+    def __init__(self, d=None):
+        self.follow_ups: Optional[List[FollowUp]] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "PushFollowUpMessageRequestBodyBuilder":
+        return PushFollowUpMessageRequestBodyBuilder()
+
+
+class PushFollowUpMessageRequestBodyBuilder(object):
+    def __init__(self) -> None:
+        self._push_follow_up_message_request_body = PushFollowUpMessageRequestBody()
+
+    def follow_ups(self, follow_ups: List[FollowUp]) -> "PushFollowUpMessageRequestBodyBuilder":
+        self._push_follow_up_message_request_body.follow_ups = follow_ups
+        return self
+
+    def build(self) -> "PushFollowUpMessageRequestBody":
+        return self._push_follow_up_message_request_body
diff --git a/lark_channel/api/im/v1/model/push_follow_up_message_response.py b/lark_channel/api/im/v1/model/push_follow_up_message_response.py
new file mode 100644
index 0000000..c3b0133
--- /dev/null
+++ b/lark_channel/api/im/v1/model/push_follow_up_message_response.py
@@ -0,0 +1,14 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+
+
+class PushFollowUpMessageResponse(BaseResponse):
+    _types = {
+
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/read_user.py b/lark_channel/api/im/v1/model/read_user.py
new file mode 100644
index 0000000..e7e6e9e
--- /dev/null
+++ b/lark_channel/api/im/v1/model/read_user.py
@@ -0,0 +1,46 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class ReadUser(object):
+    _types = {
+        "user_id_type": str,
+        "user_id": str,
+        "timestamp": str,
+        "tenant_key": str,
+    }
+
+    def __init__(self, d=None):
+        self.user_id_type: Optional[str] = None
+        self.user_id: Optional[str] = None
+        self.timestamp: Optional[str] = None
+        self.tenant_key: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "ReadUserBuilder":
+        return ReadUserBuilder()
+
+
+class ReadUserBuilder(object):
+    def __init__(self) -> None:
+        self._read_user = ReadUser()
+
+    def user_id_type(self, user_id_type: str) -> "ReadUserBuilder":
+        self._read_user.user_id_type = user_id_type
+        return self
+
+    def user_id(self, user_id: str) -> "ReadUserBuilder":
+        self._read_user.user_id = user_id
+        return self
+
+    def timestamp(self, timestamp: str) -> "ReadUserBuilder":
+        self._read_user.timestamp = timestamp
+        return self
+
+    def tenant_key(self, tenant_key: str) -> "ReadUserBuilder":
+        self._read_user.tenant_key = tenant_key
+        return self
+
+    def build(self) -> "ReadUser":
+        return self._read_user
diff --git a/lark_channel/api/im/v1/model/read_users_message_request.py b/lark_channel/api/im/v1/model/read_users_message_request.py
new file mode 100644
index 0000000..a1898cf
--- /dev/null
+++ b/lark_channel/api/im/v1/model/read_users_message_request.py
@@ -0,0 +1,49 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+
+
+class ReadUsersMessageRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.user_id_type: Optional[str] = None
+        self.page_size: Optional[int] = None
+        self.page_token: Optional[str] = None
+        self.message_id: Optional[str] = None
+
+    @staticmethod
+    def builder() -> "ReadUsersMessageRequestBuilder":
+        return ReadUsersMessageRequestBuilder()
+
+
+class ReadUsersMessageRequestBuilder(object):
+
+    def __init__(self) -> None:
+        read_users_message_request = ReadUsersMessageRequest()
+        read_users_message_request.http_method = HttpMethod.GET
+        read_users_message_request.uri = "/open-apis/im/v1/messages/:message_id/read_users"
+        read_users_message_request.token_types = {AccessTokenType.TENANT}
+        self._read_users_message_request: ReadUsersMessageRequest = read_users_message_request
+
+    def user_id_type(self, user_id_type: str) -> "ReadUsersMessageRequestBuilder":
+        self._read_users_message_request.user_id_type = user_id_type
+        self._read_users_message_request.add_query("user_id_type", user_id_type)
+        return self
+
+    def page_size(self, page_size: int) -> "ReadUsersMessageRequestBuilder":
+        self._read_users_message_request.page_size = page_size
+        self._read_users_message_request.add_query("page_size", page_size)
+        return self
+
+    def page_token(self, page_token: str) -> "ReadUsersMessageRequestBuilder":
+        self._read_users_message_request.page_token = page_token
+        self._read_users_message_request.add_query("page_token", page_token)
+        return self
+
+    def message_id(self, message_id: str) -> "ReadUsersMessageRequestBuilder":
+        self._read_users_message_request.message_id = message_id
+        self._read_users_message_request.paths["message_id"] = str(message_id)
+        return self
+
+    def build(self) -> ReadUsersMessageRequest:
+        return self._read_users_message_request
diff --git a/lark_channel/api/im/v1/model/read_users_message_request_body.py b/lark_channel/api/im/v1/model/read_users_message_request_body.py
new file mode 100644
index 0000000..43f83e1
--- /dev/null
+++ b/lark_channel/api/im/v1/model/read_users_message_request_body.py
@@ -0,0 +1,22 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class ReadUsersMessageRequestBody(object):
+    _types = {
+    }
+
+    def __init__(self, d=None):
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "ReadUsersMessageRequestBodyBuilder":
+        return ReadUsersMessageRequestBodyBuilder()
+
+
+class ReadUsersMessageRequestBodyBuilder(object):
+    def __init__(self) -> None:
+        self._read_users_message_request_body = ReadUsersMessageRequestBody()
+
+    def build(self) -> "ReadUsersMessageRequestBody":
+        return self._read_users_message_request_body
diff --git a/lark_channel/api/im/v1/model/read_users_message_response.py b/lark_channel/api/im/v1/model/read_users_message_response.py
new file mode 100644
index 0000000..e16660e
--- /dev/null
+++ b/lark_channel/api/im/v1/model/read_users_message_response.py
@@ -0,0 +1,15 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+from .read_users_message_response_body import ReadUsersMessageResponseBody
+
+
+class ReadUsersMessageResponse(BaseResponse):
+    _types = {
+        "data": ReadUsersMessageResponseBody
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.data: Optional[ReadUsersMessageResponseBody] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/read_users_message_response_body.py b/lark_channel/api/im/v1/model/read_users_message_response_body.py
new file mode 100644
index 0000000..8dc1fee
--- /dev/null
+++ b/lark_channel/api/im/v1/model/read_users_message_response_body.py
@@ -0,0 +1,41 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .read_user import ReadUser
+
+
+class ReadUsersMessageResponseBody(object):
+    _types = {
+        "items": List[ReadUser],
+        "has_more": bool,
+        "page_token": str,
+    }
+
+    def __init__(self, d=None):
+        self.items: Optional[List[ReadUser]] = None
+        self.has_more: Optional[bool] = None
+        self.page_token: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "ReadUsersMessageResponseBodyBuilder":
+        return ReadUsersMessageResponseBodyBuilder()
+
+
+class ReadUsersMessageResponseBodyBuilder(object):
+    def __init__(self) -> None:
+        self._read_users_message_response_body = ReadUsersMessageResponseBody()
+
+    def items(self, items: List[ReadUser]) -> "ReadUsersMessageResponseBodyBuilder":
+        self._read_users_message_response_body.items = items
+        return self
+
+    def has_more(self, has_more: bool) -> "ReadUsersMessageResponseBodyBuilder":
+        self._read_users_message_response_body.has_more = has_more
+        return self
+
+    def page_token(self, page_token: str) -> "ReadUsersMessageResponseBodyBuilder":
+        self._read_users_message_response_body.page_token = page_token
+        return self
+
+    def build(self) -> "ReadUsersMessageResponseBody":
+        return self._read_users_message_response_body
diff --git a/lark_channel/api/im/v1/model/reply_message_request.py b/lark_channel/api/im/v1/model/reply_message_request.py
new file mode 100644
index 0000000..2ed0543
--- /dev/null
+++ b/lark_channel/api/im/v1/model/reply_message_request.py
@@ -0,0 +1,38 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .reply_message_request_body import ReplyMessageRequestBody
+
+
+class ReplyMessageRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.message_id: Optional[str] = None
+        self.request_body: Optional[ReplyMessageRequestBody] = None
+
+    @staticmethod
+    def builder() -> "ReplyMessageRequestBuilder":
+        return ReplyMessageRequestBuilder()
+
+
+class ReplyMessageRequestBuilder(object):
+
+    def __init__(self) -> None:
+        reply_message_request = ReplyMessageRequest()
+        reply_message_request.http_method = HttpMethod.POST
+        reply_message_request.uri = "/open-apis/im/v1/messages/:message_id/reply"
+        reply_message_request.token_types = {AccessTokenType.TENANT, AccessTokenType.USER}
+        self._reply_message_request: ReplyMessageRequest = reply_message_request
+
+    def message_id(self, message_id: str) -> "ReplyMessageRequestBuilder":
+        self._reply_message_request.message_id = message_id
+        self._reply_message_request.paths["message_id"] = str(message_id)
+        return self
+
+    def request_body(self, request_body: ReplyMessageRequestBody) -> "ReplyMessageRequestBuilder":
+        self._reply_message_request.request_body = request_body
+        self._reply_message_request.body = request_body
+        return self
+
+    def build(self) -> ReplyMessageRequest:
+        return self._reply_message_request
diff --git a/lark_channel/api/im/v1/model/reply_message_request_body.py b/lark_channel/api/im/v1/model/reply_message_request_body.py
new file mode 100644
index 0000000..4656f8b
--- /dev/null
+++ b/lark_channel/api/im/v1/model/reply_message_request_body.py
@@ -0,0 +1,46 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class ReplyMessageRequestBody(object):
+    _types = {
+        "content": str,
+        "msg_type": str,
+        "reply_in_thread": bool,
+        "uuid": str,
+    }
+
+    def __init__(self, d=None):
+        self.content: Optional[str] = None
+        self.msg_type: Optional[str] = None
+        self.reply_in_thread: Optional[bool] = None
+        self.uuid: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "ReplyMessageRequestBodyBuilder":
+        return ReplyMessageRequestBodyBuilder()
+
+
+class ReplyMessageRequestBodyBuilder(object):
+    def __init__(self) -> None:
+        self._reply_message_request_body = ReplyMessageRequestBody()
+
+    def content(self, content: str) -> "ReplyMessageRequestBodyBuilder":
+        self._reply_message_request_body.content = content
+        return self
+
+    def msg_type(self, msg_type: str) -> "ReplyMessageRequestBodyBuilder":
+        self._reply_message_request_body.msg_type = msg_type
+        return self
+
+    def reply_in_thread(self, reply_in_thread: bool) -> "ReplyMessageRequestBodyBuilder":
+        self._reply_message_request_body.reply_in_thread = reply_in_thread
+        return self
+
+    def uuid(self, uuid: str) -> "ReplyMessageRequestBodyBuilder":
+        self._reply_message_request_body.uuid = uuid
+        return self
+
+    def build(self) -> "ReplyMessageRequestBody":
+        return self._reply_message_request_body
diff --git a/lark_channel/api/im/v1/model/reply_message_response.py b/lark_channel/api/im/v1/model/reply_message_response.py
new file mode 100644
index 0000000..a302017
--- /dev/null
+++ b/lark_channel/api/im/v1/model/reply_message_response.py
@@ -0,0 +1,15 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+from .reply_message_response_body import ReplyMessageResponseBody
+
+
+class ReplyMessageResponse(BaseResponse):
+    _types = {
+        "data": ReplyMessageResponseBody
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.data: Optional[ReplyMessageResponseBody] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/reply_message_response_body.py b/lark_channel/api/im/v1/model/reply_message_response_body.py
new file mode 100644
index 0000000..c77cd91
--- /dev/null
+++ b/lark_channel/api/im/v1/model/reply_message_response_body.py
@@ -0,0 +1,109 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .sender import Sender
+from .message_body import MessageBody
+from .mention import Mention
+
+
+class ReplyMessageResponseBody(object):
+    _types = {
+        "message_id": str,
+        "root_id": str,
+        "parent_id": str,
+        "thread_id": str,
+        "msg_type": str,
+        "create_time": int,
+        "update_time": int,
+        "deleted": bool,
+        "updated": bool,
+        "chat_id": str,
+        "sender": Sender,
+        "body": MessageBody,
+        "mentions": List[Mention],
+        "upper_message_id": str,
+    }
+
+    def __init__(self, d=None):
+        self.message_id: Optional[str] = None
+        self.root_id: Optional[str] = None
+        self.parent_id: Optional[str] = None
+        self.thread_id: Optional[str] = None
+        self.msg_type: Optional[str] = None
+        self.create_time: Optional[int] = None
+        self.update_time: Optional[int] = None
+        self.deleted: Optional[bool] = None
+        self.updated: Optional[bool] = None
+        self.chat_id: Optional[str] = None
+        self.sender: Optional[Sender] = None
+        self.body: Optional[MessageBody] = None
+        self.mentions: Optional[List[Mention]] = None
+        self.upper_message_id: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "ReplyMessageResponseBodyBuilder":
+        return ReplyMessageResponseBodyBuilder()
+
+
+class ReplyMessageResponseBodyBuilder(object):
+    def __init__(self) -> None:
+        self._reply_message_response_body = ReplyMessageResponseBody()
+
+    def message_id(self, message_id: str) -> "ReplyMessageResponseBodyBuilder":
+        self._reply_message_response_body.message_id = message_id
+        return self
+
+    def root_id(self, root_id: str) -> "ReplyMessageResponseBodyBuilder":
+        self._reply_message_response_body.root_id = root_id
+        return self
+
+    def parent_id(self, parent_id: str) -> "ReplyMessageResponseBodyBuilder":
+        self._reply_message_response_body.parent_id = parent_id
+        return self
+
+    def thread_id(self, thread_id: str) -> "ReplyMessageResponseBodyBuilder":
+        self._reply_message_response_body.thread_id = thread_id
+        return self
+
+    def msg_type(self, msg_type: str) -> "ReplyMessageResponseBodyBuilder":
+        self._reply_message_response_body.msg_type = msg_type
+        return self
+
+    def create_time(self, create_time: int) -> "ReplyMessageResponseBodyBuilder":
+        self._reply_message_response_body.create_time = create_time
+        return self
+
+    def update_time(self, update_time: int) -> "ReplyMessageResponseBodyBuilder":
+        self._reply_message_response_body.update_time = update_time
+        return self
+
+    def deleted(self, deleted: bool) -> "ReplyMessageResponseBodyBuilder":
+        self._reply_message_response_body.deleted = deleted
+        return self
+
+    def updated(self, updated: bool) -> "ReplyMessageResponseBodyBuilder":
+        self._reply_message_response_body.updated = updated
+        return self
+
+    def chat_id(self, chat_id: str) -> "ReplyMessageResponseBodyBuilder":
+        self._reply_message_response_body.chat_id = chat_id
+        return self
+
+    def sender(self, sender: Sender) -> "ReplyMessageResponseBodyBuilder":
+        self._reply_message_response_body.sender = sender
+        return self
+
+    def body(self, body: MessageBody) -> "ReplyMessageResponseBodyBuilder":
+        self._reply_message_response_body.body = body
+        return self
+
+    def mentions(self, mentions: List[Mention]) -> "ReplyMessageResponseBodyBuilder":
+        self._reply_message_response_body.mentions = mentions
+        return self
+
+    def upper_message_id(self, upper_message_id: str) -> "ReplyMessageResponseBodyBuilder":
+        self._reply_message_response_body.upper_message_id = upper_message_id
+        return self
+
+    def build(self) -> "ReplyMessageResponseBody":
+        return self._reply_message_response_body
diff --git a/lark_channel/api/im/v1/model/restricted_mode_setting.py b/lark_channel/api/im/v1/model/restricted_mode_setting.py
new file mode 100644
index 0000000..86a0cd1
--- /dev/null
+++ b/lark_channel/api/im/v1/model/restricted_mode_setting.py
@@ -0,0 +1,47 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class RestrictedModeSetting(object):
+    _types = {
+        "status": bool,
+        "screenshot_has_permission_setting": str,
+        "download_has_permission_setting": str,
+        "message_has_permission_setting": str,
+    }
+
+    def __init__(self, d=None):
+        self.status: Optional[bool] = None
+        self.screenshot_has_permission_setting: Optional[str] = None
+        self.download_has_permission_setting: Optional[str] = None
+        self.message_has_permission_setting: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "RestrictedModeSettingBuilder":
+        return RestrictedModeSettingBuilder()
+
+
+class RestrictedModeSettingBuilder(object):
+    def __init__(self) -> None:
+        self._restricted_mode_setting = RestrictedModeSetting()
+
+    def status(self, status: bool) -> "RestrictedModeSettingBuilder":
+        self._restricted_mode_setting.status = status
+        return self
+
+    def screenshot_has_permission_setting(self,
+                                          screenshot_has_permission_setting: str) -> "RestrictedModeSettingBuilder":
+        self._restricted_mode_setting.screenshot_has_permission_setting = screenshot_has_permission_setting
+        return self
+
+    def download_has_permission_setting(self, download_has_permission_setting: str) -> "RestrictedModeSettingBuilder":
+        self._restricted_mode_setting.download_has_permission_setting = download_has_permission_setting
+        return self
+
+    def message_has_permission_setting(self, message_has_permission_setting: str) -> "RestrictedModeSettingBuilder":
+        self._restricted_mode_setting.message_has_permission_setting = message_has_permission_setting
+        return self
+
+    def build(self) -> "RestrictedModeSetting":
+        return self._restricted_mode_setting
diff --git a/lark_channel/api/im/v1/model/search_chat_request.py b/lark_channel/api/im/v1/model/search_chat_request.py
new file mode 100644
index 0000000..fe5d933
--- /dev/null
+++ b/lark_channel/api/im/v1/model/search_chat_request.py
@@ -0,0 +1,49 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+
+
+class SearchChatRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.user_id_type: Optional[str] = None
+        self.query: Optional[str] = None
+        self.page_token: Optional[str] = None
+        self.page_size: Optional[int] = None
+
+    @staticmethod
+    def builder() -> "SearchChatRequestBuilder":
+        return SearchChatRequestBuilder()
+
+
+class SearchChatRequestBuilder(object):
+
+    def __init__(self) -> None:
+        search_chat_request = SearchChatRequest()
+        search_chat_request.http_method = HttpMethod.GET
+        search_chat_request.uri = "/open-apis/im/v1/chats/search"
+        search_chat_request.token_types = {AccessTokenType.USER, AccessTokenType.TENANT}
+        self._search_chat_request: SearchChatRequest = search_chat_request
+
+    def user_id_type(self, user_id_type: str) -> "SearchChatRequestBuilder":
+        self._search_chat_request.user_id_type = user_id_type
+        self._search_chat_request.add_query("user_id_type", user_id_type)
+        return self
+
+    def query(self, query: str) -> "SearchChatRequestBuilder":
+        self._search_chat_request.query = query
+        self._search_chat_request.add_query("query", query)
+        return self
+
+    def page_token(self, page_token: str) -> "SearchChatRequestBuilder":
+        self._search_chat_request.page_token = page_token
+        self._search_chat_request.add_query("page_token", page_token)
+        return self
+
+    def page_size(self, page_size: int) -> "SearchChatRequestBuilder":
+        self._search_chat_request.page_size = page_size
+        self._search_chat_request.add_query("page_size", page_size)
+        return self
+
+    def build(self) -> SearchChatRequest:
+        return self._search_chat_request
diff --git a/lark_channel/api/im/v1/model/search_chat_response.py b/lark_channel/api/im/v1/model/search_chat_response.py
new file mode 100644
index 0000000..480785c
--- /dev/null
+++ b/lark_channel/api/im/v1/model/search_chat_response.py
@@ -0,0 +1,15 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+from .search_chat_response_body import SearchChatResponseBody
+
+
+class SearchChatResponse(BaseResponse):
+    _types = {
+        "data": SearchChatResponseBody
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.data: Optional[SearchChatResponseBody] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/search_chat_response_body.py b/lark_channel/api/im/v1/model/search_chat_response_body.py
new file mode 100644
index 0000000..029b434
--- /dev/null
+++ b/lark_channel/api/im/v1/model/search_chat_response_body.py
@@ -0,0 +1,41 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .list_chat import ListChat
+
+
+class SearchChatResponseBody(object):
+    _types = {
+        "items": List[ListChat],
+        "page_token": str,
+        "has_more": bool,
+    }
+
+    def __init__(self, d=None):
+        self.items: Optional[List[ListChat]] = None
+        self.page_token: Optional[str] = None
+        self.has_more: Optional[bool] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "SearchChatResponseBodyBuilder":
+        return SearchChatResponseBodyBuilder()
+
+
+class SearchChatResponseBodyBuilder(object):
+    def __init__(self) -> None:
+        self._search_chat_response_body = SearchChatResponseBody()
+
+    def items(self, items: List[ListChat]) -> "SearchChatResponseBodyBuilder":
+        self._search_chat_response_body.items = items
+        return self
+
+    def page_token(self, page_token: str) -> "SearchChatResponseBodyBuilder":
+        self._search_chat_response_body.page_token = page_token
+        return self
+
+    def has_more(self, has_more: bool) -> "SearchChatResponseBodyBuilder":
+        self._search_chat_response_body.has_more = has_more
+        return self
+
+    def build(self) -> "SearchChatResponseBody":
+        return self._search_chat_response_body
diff --git a/lark_channel/api/im/v1/model/sender.py b/lark_channel/api/im/v1/model/sender.py
new file mode 100644
index 0000000..36589e3
--- /dev/null
+++ b/lark_channel/api/im/v1/model/sender.py
@@ -0,0 +1,46 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class Sender(object):
+    _types = {
+        "id": str,
+        "id_type": str,
+        "sender_type": str,
+        "tenant_key": str,
+    }
+
+    def __init__(self, d=None):
+        self.id: Optional[str] = None
+        self.id_type: Optional[str] = None
+        self.sender_type: Optional[str] = None
+        self.tenant_key: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "SenderBuilder":
+        return SenderBuilder()
+
+
+class SenderBuilder(object):
+    def __init__(self) -> None:
+        self._sender = Sender()
+
+    def id(self, id: str) -> "SenderBuilder":
+        self._sender.id = id
+        return self
+
+    def id_type(self, id_type: str) -> "SenderBuilder":
+        self._sender.id_type = id_type
+        return self
+
+    def sender_type(self, sender_type: str) -> "SenderBuilder":
+        self._sender.sender_type = sender_type
+        return self
+
+    def tenant_key(self, tenant_key: str) -> "SenderBuilder":
+        self._sender.tenant_key = tenant_key
+        return self
+
+    def build(self) -> "Sender":
+        return self._sender
diff --git a/lark_channel/api/im/v1/model/update_chat_request.py b/lark_channel/api/im/v1/model/update_chat_request.py
new file mode 100644
index 0000000..24ec4ac
--- /dev/null
+++ b/lark_channel/api/im/v1/model/update_chat_request.py
@@ -0,0 +1,44 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .update_chat_request_body import UpdateChatRequestBody
+
+
+class UpdateChatRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.user_id_type: Optional[str] = None
+        self.chat_id: Optional[str] = None
+        self.request_body: Optional[UpdateChatRequestBody] = None
+
+    @staticmethod
+    def builder() -> "UpdateChatRequestBuilder":
+        return UpdateChatRequestBuilder()
+
+
+class UpdateChatRequestBuilder(object):
+
+    def __init__(self) -> None:
+        update_chat_request = UpdateChatRequest()
+        update_chat_request.http_method = HttpMethod.PUT
+        update_chat_request.uri = "/open-apis/im/v1/chats/:chat_id"
+        update_chat_request.token_types = {AccessTokenType.TENANT, AccessTokenType.USER}
+        self._update_chat_request: UpdateChatRequest = update_chat_request
+
+    def user_id_type(self, user_id_type: str) -> "UpdateChatRequestBuilder":
+        self._update_chat_request.user_id_type = user_id_type
+        self._update_chat_request.add_query("user_id_type", user_id_type)
+        return self
+
+    def chat_id(self, chat_id: str) -> "UpdateChatRequestBuilder":
+        self._update_chat_request.chat_id = chat_id
+        self._update_chat_request.paths["chat_id"] = str(chat_id)
+        return self
+
+    def request_body(self, request_body: UpdateChatRequestBody) -> "UpdateChatRequestBuilder":
+        self._update_chat_request.request_body = request_body
+        self._update_chat_request.body = request_body
+        return self
+
+    def build(self) -> UpdateChatRequest:
+        return self._update_chat_request
diff --git a/lark_channel/api/im/v1/model/update_chat_request_body.py b/lark_channel/api/im/v1/model/update_chat_request_body.py
new file mode 100644
index 0000000..b31a0f9
--- /dev/null
+++ b/lark_channel/api/im/v1/model/update_chat_request_body.py
@@ -0,0 +1,150 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .i18n_names import I18nNames
+from .restricted_mode_setting import RestrictedModeSetting
+
+
+class UpdateChatRequestBody(object):
+    _types = {
+        "avatar": str,
+        "name": str,
+        "description": str,
+        "i18n_names": I18nNames,
+        "add_member_permission": str,
+        "share_card_permission": str,
+        "at_all_permission": str,
+        "edit_permission": str,
+        "owner_id": str,
+        "join_message_visibility": str,
+        "leave_message_visibility": str,
+        "membership_approval": str,
+        "labels": List[str],
+        "toolkit_ids": List[int],
+        "restricted_mode_setting": RestrictedModeSetting,
+        "chat_type": str,
+        "group_message_type": str,
+        "urgent_setting": str,
+        "video_conference_setting": str,
+        "pin_manage_setting": str,
+        "hide_member_count_setting": str,
+    }
+
+    def __init__(self, d=None):
+        self.avatar: Optional[str] = None
+        self.name: Optional[str] = None
+        self.description: Optional[str] = None
+        self.i18n_names: Optional[I18nNames] = None
+        self.add_member_permission: Optional[str] = None
+        self.share_card_permission: Optional[str] = None
+        self.at_all_permission: Optional[str] = None
+        self.edit_permission: Optional[str] = None
+        self.owner_id: Optional[str] = None
+        self.join_message_visibility: Optional[str] = None
+        self.leave_message_visibility: Optional[str] = None
+        self.membership_approval: Optional[str] = None
+        self.labels: Optional[List[str]] = None
+        self.toolkit_ids: Optional[List[int]] = None
+        self.restricted_mode_setting: Optional[RestrictedModeSetting] = None
+        self.chat_type: Optional[str] = None
+        self.group_message_type: Optional[str] = None
+        self.urgent_setting: Optional[str] = None
+        self.video_conference_setting: Optional[str] = None
+        self.pin_manage_setting: Optional[str] = None
+        self.hide_member_count_setting: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "UpdateChatRequestBodyBuilder":
+        return UpdateChatRequestBodyBuilder()
+
+
+class UpdateChatRequestBodyBuilder(object):
+    def __init__(self) -> None:
+        self._update_chat_request_body = UpdateChatRequestBody()
+
+    def avatar(self, avatar: str) -> "UpdateChatRequestBodyBuilder":
+        self._update_chat_request_body.avatar = avatar
+        return self
+
+    def name(self, name: str) -> "UpdateChatRequestBodyBuilder":
+        self._update_chat_request_body.name = name
+        return self
+
+    def description(self, description: str) -> "UpdateChatRequestBodyBuilder":
+        self._update_chat_request_body.description = description
+        return self
+
+    def i18n_names(self, i18n_names: I18nNames) -> "UpdateChatRequestBodyBuilder":
+        self._update_chat_request_body.i18n_names = i18n_names
+        return self
+
+    def add_member_permission(self, add_member_permission: str) -> "UpdateChatRequestBodyBuilder":
+        self._update_chat_request_body.add_member_permission = add_member_permission
+        return self
+
+    def share_card_permission(self, share_card_permission: str) -> "UpdateChatRequestBodyBuilder":
+        self._update_chat_request_body.share_card_permission = share_card_permission
+        return self
+
+    def at_all_permission(self, at_all_permission: str) -> "UpdateChatRequestBodyBuilder":
+        self._update_chat_request_body.at_all_permission = at_all_permission
+        return self
+
+    def edit_permission(self, edit_permission: str) -> "UpdateChatRequestBodyBuilder":
+        self._update_chat_request_body.edit_permission = edit_permission
+        return self
+
+    def owner_id(self, owner_id: str) -> "UpdateChatRequestBodyBuilder":
+        self._update_chat_request_body.owner_id = owner_id
+        return self
+
+    def join_message_visibility(self, join_message_visibility: str) -> "UpdateChatRequestBodyBuilder":
+        self._update_chat_request_body.join_message_visibility = join_message_visibility
+        return self
+
+    def leave_message_visibility(self, leave_message_visibility: str) -> "UpdateChatRequestBodyBuilder":
+        self._update_chat_request_body.leave_message_visibility = leave_message_visibility
+        return self
+
+    def membership_approval(self, membership_approval: str) -> "UpdateChatRequestBodyBuilder":
+        self._update_chat_request_body.membership_approval = membership_approval
+        return self
+
+    def labels(self, labels: List[str]) -> "UpdateChatRequestBodyBuilder":
+        self._update_chat_request_body.labels = labels
+        return self
+
+    def toolkit_ids(self, toolkit_ids: List[int]) -> "UpdateChatRequestBodyBuilder":
+        self._update_chat_request_body.toolkit_ids = toolkit_ids
+        return self
+
+    def restricted_mode_setting(self, restricted_mode_setting: RestrictedModeSetting) -> "UpdateChatRequestBodyBuilder":
+        self._update_chat_request_body.restricted_mode_setting = restricted_mode_setting
+        return self
+
+    def chat_type(self, chat_type: str) -> "UpdateChatRequestBodyBuilder":
+        self._update_chat_request_body.chat_type = chat_type
+        return self
+
+    def group_message_type(self, group_message_type: str) -> "UpdateChatRequestBodyBuilder":
+        self._update_chat_request_body.group_message_type = group_message_type
+        return self
+
+    def urgent_setting(self, urgent_setting: str) -> "UpdateChatRequestBodyBuilder":
+        self._update_chat_request_body.urgent_setting = urgent_setting
+        return self
+
+    def video_conference_setting(self, video_conference_setting: str) -> "UpdateChatRequestBodyBuilder":
+        self._update_chat_request_body.video_conference_setting = video_conference_setting
+        return self
+
+    def pin_manage_setting(self, pin_manage_setting: str) -> "UpdateChatRequestBodyBuilder":
+        self._update_chat_request_body.pin_manage_setting = pin_manage_setting
+        return self
+
+    def hide_member_count_setting(self, hide_member_count_setting: str) -> "UpdateChatRequestBodyBuilder":
+        self._update_chat_request_body.hide_member_count_setting = hide_member_count_setting
+        return self
+
+    def build(self) -> "UpdateChatRequestBody":
+        return self._update_chat_request_body
diff --git a/lark_channel/api/im/v1/model/update_chat_response.py b/lark_channel/api/im/v1/model/update_chat_response.py
new file mode 100644
index 0000000..3db817a
--- /dev/null
+++ b/lark_channel/api/im/v1/model/update_chat_response.py
@@ -0,0 +1,14 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+
+
+class UpdateChatResponse(BaseResponse):
+    _types = {
+
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/update_message_request.py b/lark_channel/api/im/v1/model/update_message_request.py
new file mode 100644
index 0000000..e9946c2
--- /dev/null
+++ b/lark_channel/api/im/v1/model/update_message_request.py
@@ -0,0 +1,38 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .update_message_request_body import UpdateMessageRequestBody
+
+
+class UpdateMessageRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.message_id: Optional[str] = None
+        self.request_body: Optional[UpdateMessageRequestBody] = None
+
+    @staticmethod
+    def builder() -> "UpdateMessageRequestBuilder":
+        return UpdateMessageRequestBuilder()
+
+
+class UpdateMessageRequestBuilder(object):
+
+    def __init__(self) -> None:
+        update_message_request = UpdateMessageRequest()
+        update_message_request.http_method = HttpMethod.PUT
+        update_message_request.uri = "/open-apis/im/v1/messages/:message_id"
+        update_message_request.token_types = {AccessTokenType.TENANT}
+        self._update_message_request: UpdateMessageRequest = update_message_request
+
+    def message_id(self, message_id: str) -> "UpdateMessageRequestBuilder":
+        self._update_message_request.message_id = message_id
+        self._update_message_request.paths["message_id"] = str(message_id)
+        return self
+
+    def request_body(self, request_body: UpdateMessageRequestBody) -> "UpdateMessageRequestBuilder":
+        self._update_message_request.request_body = request_body
+        self._update_message_request.body = request_body
+        return self
+
+    def build(self) -> UpdateMessageRequest:
+        return self._update_message_request
diff --git a/lark_channel/api/im/v1/model/update_message_request_body.py b/lark_channel/api/im/v1/model/update_message_request_body.py
new file mode 100644
index 0000000..7da0c9d
--- /dev/null
+++ b/lark_channel/api/im/v1/model/update_message_request_body.py
@@ -0,0 +1,34 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class UpdateMessageRequestBody(object):
+    _types = {
+        "msg_type": str,
+        "content": str,
+    }
+
+    def __init__(self, d=None):
+        self.msg_type: Optional[str] = None
+        self.content: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "UpdateMessageRequestBodyBuilder":
+        return UpdateMessageRequestBodyBuilder()
+
+
+class UpdateMessageRequestBodyBuilder(object):
+    def __init__(self) -> None:
+        self._update_message_request_body = UpdateMessageRequestBody()
+
+    def msg_type(self, msg_type: str) -> "UpdateMessageRequestBodyBuilder":
+        self._update_message_request_body.msg_type = msg_type
+        return self
+
+    def content(self, content: str) -> "UpdateMessageRequestBodyBuilder":
+        self._update_message_request_body.content = content
+        return self
+
+    def build(self) -> "UpdateMessageRequestBody":
+        return self._update_message_request_body
diff --git a/lark_channel/api/im/v1/model/update_message_response.py b/lark_channel/api/im/v1/model/update_message_response.py
new file mode 100644
index 0000000..4173d98
--- /dev/null
+++ b/lark_channel/api/im/v1/model/update_message_response.py
@@ -0,0 +1,15 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+from .update_message_response_body import UpdateMessageResponseBody
+
+
+class UpdateMessageResponse(BaseResponse):
+    _types = {
+        "data": UpdateMessageResponseBody
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.data: Optional[UpdateMessageResponseBody] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/update_message_response_body.py b/lark_channel/api/im/v1/model/update_message_response_body.py
new file mode 100644
index 0000000..e74733c
--- /dev/null
+++ b/lark_channel/api/im/v1/model/update_message_response_body.py
@@ -0,0 +1,109 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from .sender import Sender
+from .message_body import MessageBody
+from .mention import Mention
+
+
+class UpdateMessageResponseBody(object):
+    _types = {
+        "message_id": str,
+        "root_id": str,
+        "parent_id": str,
+        "thread_id": str,
+        "msg_type": str,
+        "create_time": int,
+        "update_time": int,
+        "deleted": bool,
+        "updated": bool,
+        "chat_id": str,
+        "sender": Sender,
+        "body": MessageBody,
+        "mentions": List[Mention],
+        "upper_message_id": str,
+    }
+
+    def __init__(self, d=None):
+        self.message_id: Optional[str] = None
+        self.root_id: Optional[str] = None
+        self.parent_id: Optional[str] = None
+        self.thread_id: Optional[str] = None
+        self.msg_type: Optional[str] = None
+        self.create_time: Optional[int] = None
+        self.update_time: Optional[int] = None
+        self.deleted: Optional[bool] = None
+        self.updated: Optional[bool] = None
+        self.chat_id: Optional[str] = None
+        self.sender: Optional[Sender] = None
+        self.body: Optional[MessageBody] = None
+        self.mentions: Optional[List[Mention]] = None
+        self.upper_message_id: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "UpdateMessageResponseBodyBuilder":
+        return UpdateMessageResponseBodyBuilder()
+
+
+class UpdateMessageResponseBodyBuilder(object):
+    def __init__(self) -> None:
+        self._update_message_response_body = UpdateMessageResponseBody()
+
+    def message_id(self, message_id: str) -> "UpdateMessageResponseBodyBuilder":
+        self._update_message_response_body.message_id = message_id
+        return self
+
+    def root_id(self, root_id: str) -> "UpdateMessageResponseBodyBuilder":
+        self._update_message_response_body.root_id = root_id
+        return self
+
+    def parent_id(self, parent_id: str) -> "UpdateMessageResponseBodyBuilder":
+        self._update_message_response_body.parent_id = parent_id
+        return self
+
+    def thread_id(self, thread_id: str) -> "UpdateMessageResponseBodyBuilder":
+        self._update_message_response_body.thread_id = thread_id
+        return self
+
+    def msg_type(self, msg_type: str) -> "UpdateMessageResponseBodyBuilder":
+        self._update_message_response_body.msg_type = msg_type
+        return self
+
+    def create_time(self, create_time: int) -> "UpdateMessageResponseBodyBuilder":
+        self._update_message_response_body.create_time = create_time
+        return self
+
+    def update_time(self, update_time: int) -> "UpdateMessageResponseBodyBuilder":
+        self._update_message_response_body.update_time = update_time
+        return self
+
+    def deleted(self, deleted: bool) -> "UpdateMessageResponseBodyBuilder":
+        self._update_message_response_body.deleted = deleted
+        return self
+
+    def updated(self, updated: bool) -> "UpdateMessageResponseBodyBuilder":
+        self._update_message_response_body.updated = updated
+        return self
+
+    def chat_id(self, chat_id: str) -> "UpdateMessageResponseBodyBuilder":
+        self._update_message_response_body.chat_id = chat_id
+        return self
+
+    def sender(self, sender: Sender) -> "UpdateMessageResponseBodyBuilder":
+        self._update_message_response_body.sender = sender
+        return self
+
+    def body(self, body: MessageBody) -> "UpdateMessageResponseBodyBuilder":
+        self._update_message_response_body.body = body
+        return self
+
+    def mentions(self, mentions: List[Mention]) -> "UpdateMessageResponseBodyBuilder":
+        self._update_message_response_body.mentions = mentions
+        return self
+
+    def upper_message_id(self, upper_message_id: str) -> "UpdateMessageResponseBodyBuilder":
+        self._update_message_response_body.upper_message_id = upper_message_id
+        return self
+
+    def build(self) -> "UpdateMessageResponseBody":
+        return self._update_message_response_body
diff --git a/lark_channel/api/im/v1/model/urgent_app_message_request.py b/lark_channel/api/im/v1/model/urgent_app_message_request.py
new file mode 100644
index 0000000..8f2513d
--- /dev/null
+++ b/lark_channel/api/im/v1/model/urgent_app_message_request.py
@@ -0,0 +1,44 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .urgent_receivers import UrgentReceivers
+
+
+class UrgentAppMessageRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.user_id_type: Optional[str] = None
+        self.message_id: Optional[str] = None
+        self.request_body: Optional[UrgentReceivers] = None
+
+    @staticmethod
+    def builder() -> "UrgentAppMessageRequestBuilder":
+        return UrgentAppMessageRequestBuilder()
+
+
+class UrgentAppMessageRequestBuilder(object):
+
+    def __init__(self) -> None:
+        urgent_app_message_request = UrgentAppMessageRequest()
+        urgent_app_message_request.http_method = HttpMethod.PATCH
+        urgent_app_message_request.uri = "/open-apis/im/v1/messages/:message_id/urgent_app"
+        urgent_app_message_request.token_types = {AccessTokenType.TENANT}
+        self._urgent_app_message_request: UrgentAppMessageRequest = urgent_app_message_request
+
+    def user_id_type(self, user_id_type: str) -> "UrgentAppMessageRequestBuilder":
+        self._urgent_app_message_request.user_id_type = user_id_type
+        self._urgent_app_message_request.add_query("user_id_type", user_id_type)
+        return self
+
+    def message_id(self, message_id: str) -> "UrgentAppMessageRequestBuilder":
+        self._urgent_app_message_request.message_id = message_id
+        self._urgent_app_message_request.paths["message_id"] = str(message_id)
+        return self
+
+    def request_body(self, request_body: UrgentReceivers) -> "UrgentAppMessageRequestBuilder":
+        self._urgent_app_message_request.request_body = request_body
+        self._urgent_app_message_request.body = request_body
+        return self
+
+    def build(self) -> UrgentAppMessageRequest:
+        return self._urgent_app_message_request
diff --git a/lark_channel/api/im/v1/model/urgent_app_message_response.py b/lark_channel/api/im/v1/model/urgent_app_message_response.py
new file mode 100644
index 0000000..b217a5e
--- /dev/null
+++ b/lark_channel/api/im/v1/model/urgent_app_message_response.py
@@ -0,0 +1,15 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+from .urgent_app_message_response_body import UrgentAppMessageResponseBody
+
+
+class UrgentAppMessageResponse(BaseResponse):
+    _types = {
+        "data": UrgentAppMessageResponseBody
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.data: Optional[UrgentAppMessageResponseBody] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/urgent_app_message_response_body.py b/lark_channel/api/im/v1/model/urgent_app_message_response_body.py
new file mode 100644
index 0000000..6ad0db1
--- /dev/null
+++ b/lark_channel/api/im/v1/model/urgent_app_message_response_body.py
@@ -0,0 +1,28 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class UrgentAppMessageResponseBody(object):
+    _types = {
+        "invalid_user_id_list": List[str],
+    }
+
+    def __init__(self, d=None):
+        self.invalid_user_id_list: Optional[List[str]] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "UrgentAppMessageResponseBodyBuilder":
+        return UrgentAppMessageResponseBodyBuilder()
+
+
+class UrgentAppMessageResponseBodyBuilder(object):
+    def __init__(self) -> None:
+        self._urgent_app_message_response_body = UrgentAppMessageResponseBody()
+
+    def invalid_user_id_list(self, invalid_user_id_list: List[str]) -> "UrgentAppMessageResponseBodyBuilder":
+        self._urgent_app_message_response_body.invalid_user_id_list = invalid_user_id_list
+        return self
+
+    def build(self) -> "UrgentAppMessageResponseBody":
+        return self._urgent_app_message_response_body
diff --git a/lark_channel/api/im/v1/model/urgent_phone_message_request.py b/lark_channel/api/im/v1/model/urgent_phone_message_request.py
new file mode 100644
index 0000000..fc12567
--- /dev/null
+++ b/lark_channel/api/im/v1/model/urgent_phone_message_request.py
@@ -0,0 +1,44 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .urgent_receivers import UrgentReceivers
+
+
+class UrgentPhoneMessageRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.user_id_type: Optional[str] = None
+        self.message_id: Optional[str] = None
+        self.request_body: Optional[UrgentReceivers] = None
+
+    @staticmethod
+    def builder() -> "UrgentPhoneMessageRequestBuilder":
+        return UrgentPhoneMessageRequestBuilder()
+
+
+class UrgentPhoneMessageRequestBuilder(object):
+
+    def __init__(self) -> None:
+        urgent_phone_message_request = UrgentPhoneMessageRequest()
+        urgent_phone_message_request.http_method = HttpMethod.PATCH
+        urgent_phone_message_request.uri = "/open-apis/im/v1/messages/:message_id/urgent_phone"
+        urgent_phone_message_request.token_types = {AccessTokenType.TENANT}
+        self._urgent_phone_message_request: UrgentPhoneMessageRequest = urgent_phone_message_request
+
+    def user_id_type(self, user_id_type: str) -> "UrgentPhoneMessageRequestBuilder":
+        self._urgent_phone_message_request.user_id_type = user_id_type
+        self._urgent_phone_message_request.add_query("user_id_type", user_id_type)
+        return self
+
+    def message_id(self, message_id: str) -> "UrgentPhoneMessageRequestBuilder":
+        self._urgent_phone_message_request.message_id = message_id
+        self._urgent_phone_message_request.paths["message_id"] = str(message_id)
+        return self
+
+    def request_body(self, request_body: UrgentReceivers) -> "UrgentPhoneMessageRequestBuilder":
+        self._urgent_phone_message_request.request_body = request_body
+        self._urgent_phone_message_request.body = request_body
+        return self
+
+    def build(self) -> UrgentPhoneMessageRequest:
+        return self._urgent_phone_message_request
diff --git a/lark_channel/api/im/v1/model/urgent_phone_message_response.py b/lark_channel/api/im/v1/model/urgent_phone_message_response.py
new file mode 100644
index 0000000..876e4c9
--- /dev/null
+++ b/lark_channel/api/im/v1/model/urgent_phone_message_response.py
@@ -0,0 +1,15 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+from .urgent_phone_message_response_body import UrgentPhoneMessageResponseBody
+
+
+class UrgentPhoneMessageResponse(BaseResponse):
+    _types = {
+        "data": UrgentPhoneMessageResponseBody
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.data: Optional[UrgentPhoneMessageResponseBody] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/urgent_phone_message_response_body.py b/lark_channel/api/im/v1/model/urgent_phone_message_response_body.py
new file mode 100644
index 0000000..54aab50
--- /dev/null
+++ b/lark_channel/api/im/v1/model/urgent_phone_message_response_body.py
@@ -0,0 +1,28 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class UrgentPhoneMessageResponseBody(object):
+    _types = {
+        "invalid_user_id_list": List[str],
+    }
+
+    def __init__(self, d=None):
+        self.invalid_user_id_list: Optional[List[str]] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "UrgentPhoneMessageResponseBodyBuilder":
+        return UrgentPhoneMessageResponseBodyBuilder()
+
+
+class UrgentPhoneMessageResponseBodyBuilder(object):
+    def __init__(self) -> None:
+        self._urgent_phone_message_response_body = UrgentPhoneMessageResponseBody()
+
+    def invalid_user_id_list(self, invalid_user_id_list: List[str]) -> "UrgentPhoneMessageResponseBodyBuilder":
+        self._urgent_phone_message_response_body.invalid_user_id_list = invalid_user_id_list
+        return self
+
+    def build(self) -> "UrgentPhoneMessageResponseBody":
+        return self._urgent_phone_message_response_body
diff --git a/lark_channel/api/im/v1/model/urgent_receivers.py b/lark_channel/api/im/v1/model/urgent_receivers.py
new file mode 100644
index 0000000..4312850
--- /dev/null
+++ b/lark_channel/api/im/v1/model/urgent_receivers.py
@@ -0,0 +1,28 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class UrgentReceivers(object):
+    _types = {
+        "user_id_list": List[str],
+    }
+
+    def __init__(self, d=None):
+        self.user_id_list: Optional[List[str]] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "UrgentReceiversBuilder":
+        return UrgentReceiversBuilder()
+
+
+class UrgentReceiversBuilder(object):
+    def __init__(self) -> None:
+        self._urgent_receivers = UrgentReceivers()
+
+    def user_id_list(self, user_id_list: List[str]) -> "UrgentReceiversBuilder":
+        self._urgent_receivers.user_id_list = user_id_list
+        return self
+
+    def build(self) -> "UrgentReceivers":
+        return self._urgent_receivers
diff --git a/lark_channel/api/im/v1/model/urgent_sms_message_request.py b/lark_channel/api/im/v1/model/urgent_sms_message_request.py
new file mode 100644
index 0000000..a936513
--- /dev/null
+++ b/lark_channel/api/im/v1/model/urgent_sms_message_request.py
@@ -0,0 +1,44 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.model import BaseRequest
+from lark_channel.core.enum import HttpMethod, AccessTokenType
+from .urgent_receivers import UrgentReceivers
+
+
+class UrgentSmsMessageRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.user_id_type: Optional[str] = None
+        self.message_id: Optional[str] = None
+        self.request_body: Optional[UrgentReceivers] = None
+
+    @staticmethod
+    def builder() -> "UrgentSmsMessageRequestBuilder":
+        return UrgentSmsMessageRequestBuilder()
+
+
+class UrgentSmsMessageRequestBuilder(object):
+
+    def __init__(self) -> None:
+        urgent_sms_message_request = UrgentSmsMessageRequest()
+        urgent_sms_message_request.http_method = HttpMethod.PATCH
+        urgent_sms_message_request.uri = "/open-apis/im/v1/messages/:message_id/urgent_sms"
+        urgent_sms_message_request.token_types = {AccessTokenType.TENANT}
+        self._urgent_sms_message_request: UrgentSmsMessageRequest = urgent_sms_message_request
+
+    def user_id_type(self, user_id_type: str) -> "UrgentSmsMessageRequestBuilder":
+        self._urgent_sms_message_request.user_id_type = user_id_type
+        self._urgent_sms_message_request.add_query("user_id_type", user_id_type)
+        return self
+
+    def message_id(self, message_id: str) -> "UrgentSmsMessageRequestBuilder":
+        self._urgent_sms_message_request.message_id = message_id
+        self._urgent_sms_message_request.paths["message_id"] = str(message_id)
+        return self
+
+    def request_body(self, request_body: UrgentReceivers) -> "UrgentSmsMessageRequestBuilder":
+        self._urgent_sms_message_request.request_body = request_body
+        self._urgent_sms_message_request.body = request_body
+        return self
+
+    def build(self) -> UrgentSmsMessageRequest:
+        return self._urgent_sms_message_request
diff --git a/lark_channel/api/im/v1/model/urgent_sms_message_response.py b/lark_channel/api/im/v1/model/urgent_sms_message_response.py
new file mode 100644
index 0000000..740b7b5
--- /dev/null
+++ b/lark_channel/api/im/v1/model/urgent_sms_message_response.py
@@ -0,0 +1,15 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+from .urgent_sms_message_response_body import UrgentSmsMessageResponseBody
+
+
+class UrgentSmsMessageResponse(BaseResponse):
+    _types = {
+        "data": UrgentSmsMessageResponseBody
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self.data: Optional[UrgentSmsMessageResponseBody] = None
+        init(self, d, self._types)
diff --git a/lark_channel/api/im/v1/model/urgent_sms_message_response_body.py b/lark_channel/api/im/v1/model/urgent_sms_message_response_body.py
new file mode 100644
index 0000000..2803cab
--- /dev/null
+++ b/lark_channel/api/im/v1/model/urgent_sms_message_response_body.py
@@ -0,0 +1,28 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class UrgentSmsMessageResponseBody(object):
+    _types = {
+        "invalid_user_id_list": List[str],
+    }
+
+    def __init__(self, d=None):
+        self.invalid_user_id_list: Optional[List[str]] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "UrgentSmsMessageResponseBodyBuilder":
+        return UrgentSmsMessageResponseBodyBuilder()
+
+
+class UrgentSmsMessageResponseBodyBuilder(object):
+    def __init__(self) -> None:
+        self._urgent_sms_message_response_body = UrgentSmsMessageResponseBody()
+
+    def invalid_user_id_list(self, invalid_user_id_list: List[str]) -> "UrgentSmsMessageResponseBodyBuilder":
+        self._urgent_sms_message_response_body.invalid_user_id_list = invalid_user_id_list
+        return self
+
+    def build(self) -> "UrgentSmsMessageResponseBody":
+        return self._urgent_sms_message_response_body
diff --git a/lark_channel/api/im/v1/model/user_id.py b/lark_channel/api/im/v1/model/user_id.py
new file mode 100644
index 0000000..67ae276
--- /dev/null
+++ b/lark_channel/api/im/v1/model/user_id.py
@@ -0,0 +1,40 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+
+
+class UserId(object):
+    _types = {
+        "user_id": str,
+        "open_id": str,
+        "union_id": str,
+    }
+
+    def __init__(self, d=None):
+        self.user_id: Optional[str] = None
+        self.open_id: Optional[str] = None
+        self.union_id: Optional[str] = None
+        init(self, d, self._types)
+
+    @staticmethod
+    def builder() -> "UserIdBuilder":
+        return UserIdBuilder()
+
+
+class UserIdBuilder(object):
+    def __init__(self) -> None:
+        self._user_id = UserId()
+
+    def user_id(self, user_id: str) -> "UserIdBuilder":
+        self._user_id.user_id = user_id
+        return self
+
+    def open_id(self, open_id: str) -> "UserIdBuilder":
+        self._user_id.open_id = open_id
+        return self
+
+    def union_id(self, union_id: str) -> "UserIdBuilder":
+        self._user_id.union_id = union_id
+        return self
+
+    def build(self) -> "UserId":
+        return self._user_id
diff --git a/lark_channel/api/im/v1/processor.py b/lark_channel/api/im/v1/processor.py
new file mode 100644
index 0000000..f4443c8
--- /dev/null
+++ b/lark_channel/api/im/v1/processor.py
@@ -0,0 +1,159 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+
+from lark_channel.event.processor import IEventProcessor
+from .model.p2_im_chat_disbanded_v1 import P2ImChatDisbandedV1
+from .model.p2_im_chat_updated_v1 import P2ImChatUpdatedV1
+from .model.p2_im_chat_access_event_bot_p2p_chat_entered_v1 import P2ImChatAccessEventBotP2pChatEnteredV1
+from .model.p2_im_chat_member_bot_added_v1 import P2ImChatMemberBotAddedV1
+from .model.p2_im_chat_member_bot_deleted_v1 import P2ImChatMemberBotDeletedV1
+from .model.p2_im_chat_member_user_added_v1 import P2ImChatMemberUserAddedV1
+from .model.p2_im_chat_member_user_deleted_v1 import P2ImChatMemberUserDeletedV1
+from .model.p2_im_chat_member_user_withdrawn_v1 import P2ImChatMemberUserWithdrawnV1
+from .model.p2_im_message_message_read_v1 import P2ImMessageMessageReadV1
+from .model.p2_im_message_recalled_v1 import P2ImMessageRecalledV1
+from .model.p2_im_message_receive_v1 import P2ImMessageReceiveV1
+from .model.p2_im_message_reaction_created_v1 import P2ImMessageReactionCreatedV1
+from .model.p2_im_message_reaction_deleted_v1 import P2ImMessageReactionDeletedV1
+
+
+class P2ImChatDisbandedV1Processor(IEventProcessor[P2ImChatDisbandedV1]):
+    def __init__(self, f: Callable[[P2ImChatDisbandedV1], None]):
+        self.f = f
+
+    def type(self) -> Type[P2ImChatDisbandedV1]:
+        return P2ImChatDisbandedV1
+
+    def do(self, data: P2ImChatDisbandedV1) -> None:
+        self.f(data)
+
+
+class P2ImChatUpdatedV1Processor(IEventProcessor[P2ImChatUpdatedV1]):
+    def __init__(self, f: Callable[[P2ImChatUpdatedV1], None]):
+        self.f = f
+
+    def type(self) -> Type[P2ImChatUpdatedV1]:
+        return P2ImChatUpdatedV1
+
+    def do(self, data: P2ImChatUpdatedV1) -> None:
+        self.f(data)
+
+
+class P2ImChatAccessEventBotP2pChatEnteredV1Processor(IEventProcessor[P2ImChatAccessEventBotP2pChatEnteredV1]):
+    def __init__(self, f: Callable[[P2ImChatAccessEventBotP2pChatEnteredV1], None]):
+        self.f = f
+
+    def type(self) -> Type[P2ImChatAccessEventBotP2pChatEnteredV1]:
+        return P2ImChatAccessEventBotP2pChatEnteredV1
+
+    def do(self, data: P2ImChatAccessEventBotP2pChatEnteredV1) -> None:
+        self.f(data)
+
+
+class P2ImChatMemberBotAddedV1Processor(IEventProcessor[P2ImChatMemberBotAddedV1]):
+    def __init__(self, f: Callable[[P2ImChatMemberBotAddedV1], None]):
+        self.f = f
+
+    def type(self) -> Type[P2ImChatMemberBotAddedV1]:
+        return P2ImChatMemberBotAddedV1
+
+    def do(self, data: P2ImChatMemberBotAddedV1) -> None:
+        self.f(data)
+
+
+class P2ImChatMemberBotDeletedV1Processor(IEventProcessor[P2ImChatMemberBotDeletedV1]):
+    def __init__(self, f: Callable[[P2ImChatMemberBotDeletedV1], None]):
+        self.f = f
+
+    def type(self) -> Type[P2ImChatMemberBotDeletedV1]:
+        return P2ImChatMemberBotDeletedV1
+
+    def do(self, data: P2ImChatMemberBotDeletedV1) -> None:
+        self.f(data)
+
+
+class P2ImChatMemberUserAddedV1Processor(IEventProcessor[P2ImChatMemberUserAddedV1]):
+    def __init__(self, f: Callable[[P2ImChatMemberUserAddedV1], None]):
+        self.f = f
+
+    def type(self) -> Type[P2ImChatMemberUserAddedV1]:
+        return P2ImChatMemberUserAddedV1
+
+    def do(self, data: P2ImChatMemberUserAddedV1) -> None:
+        self.f(data)
+
+
+class P2ImChatMemberUserDeletedV1Processor(IEventProcessor[P2ImChatMemberUserDeletedV1]):
+    def __init__(self, f: Callable[[P2ImChatMemberUserDeletedV1], None]):
+        self.f = f
+
+    def type(self) -> Type[P2ImChatMemberUserDeletedV1]:
+        return P2ImChatMemberUserDeletedV1
+
+    def do(self, data: P2ImChatMemberUserDeletedV1) -> None:
+        self.f(data)
+
+
+class P2ImChatMemberUserWithdrawnV1Processor(IEventProcessor[P2ImChatMemberUserWithdrawnV1]):
+    def __init__(self, f: Callable[[P2ImChatMemberUserWithdrawnV1], None]):
+        self.f = f
+
+    def type(self) -> Type[P2ImChatMemberUserWithdrawnV1]:
+        return P2ImChatMemberUserWithdrawnV1
+
+    def do(self, data: P2ImChatMemberUserWithdrawnV1) -> None:
+        self.f(data)
+
+
+class P2ImMessageMessageReadV1Processor(IEventProcessor[P2ImMessageMessageReadV1]):
+    def __init__(self, f: Callable[[P2ImMessageMessageReadV1], None]):
+        self.f = f
+
+    def type(self) -> Type[P2ImMessageMessageReadV1]:
+        return P2ImMessageMessageReadV1
+
+    def do(self, data: P2ImMessageMessageReadV1) -> None:
+        self.f(data)
+
+
+class P2ImMessageRecalledV1Processor(IEventProcessor[P2ImMessageRecalledV1]):
+    def __init__(self, f: Callable[[P2ImMessageRecalledV1], None]):
+        self.f = f
+
+    def type(self) -> Type[P2ImMessageRecalledV1]:
+        return P2ImMessageRecalledV1
+
+    def do(self, data: P2ImMessageRecalledV1) -> None:
+        self.f(data)
+
+
+class P2ImMessageReceiveV1Processor(IEventProcessor[P2ImMessageReceiveV1]):
+    def __init__(self, f: Callable[[P2ImMessageReceiveV1], None]):
+        self.f = f
+
+    def type(self) -> Type[P2ImMessageReceiveV1]:
+        return P2ImMessageReceiveV1
+
+    def do(self, data: P2ImMessageReceiveV1) -> None:
+        self.f(data)
+
+
+class P2ImMessageReactionCreatedV1Processor(IEventProcessor[P2ImMessageReactionCreatedV1]):
+    def __init__(self, f: Callable[[P2ImMessageReactionCreatedV1], None]):
+        self.f = f
+
+    def type(self) -> Type[P2ImMessageReactionCreatedV1]:
+        return P2ImMessageReactionCreatedV1
+
+    def do(self, data: P2ImMessageReactionCreatedV1) -> None:
+        self.f(data)
+
+
+class P2ImMessageReactionDeletedV1Processor(IEventProcessor[P2ImMessageReactionDeletedV1]):
+    def __init__(self, f: Callable[[P2ImMessageReactionDeletedV1], None]):
+        self.f = f
+
+    def type(self) -> Type[P2ImMessageReactionDeletedV1]:
+        return P2ImMessageReactionDeletedV1
+
+    def do(self, data: P2ImMessageReactionDeletedV1) -> None:
+        self.f(data)
diff --git a/lark_channel/api/im/v1/resource/__init__.py b/lark_channel/api/im/v1/resource/__init__.py
new file mode 100644
index 0000000..8424da1
--- /dev/null
+++ b/lark_channel/api/im/v1/resource/__init__.py
@@ -0,0 +1,15 @@
+from .chat import Chat
+from .file import File
+from .image import Image
+from .message import Message
+from .message_reaction import MessageReaction
+from .message_resource import MessageResource
+
+__all__ = [
+    "Chat",
+    "File",
+    "Image",
+    "Message",
+    "MessageReaction",
+    "MessageResource",
+]
diff --git a/lark_channel/api/im/v1/resource/chat.py b/lark_channel/api/im/v1/resource/chat.py
new file mode 100644
index 0000000..dcc0a41
--- /dev/null
+++ b/lark_channel/api/im/v1/resource/chat.py
@@ -0,0 +1,280 @@
+import io
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.const import UTF_8, CONTENT_TYPE, APPLICATION_JSON
+from lark_channel.core import JSON
+from lark_channel.core.token import verify
+from lark_channel.core.http import Transport
+from lark_channel.core.model import Config, RequestOption, RawResponse
+from lark_channel.core.utils import Files
+from requests_toolbelt import MultipartEncoder
+from ..model.create_chat_request import CreateChatRequest
+from ..model.create_chat_response import CreateChatResponse
+from ..model.delete_chat_request import DeleteChatRequest
+from ..model.delete_chat_response import DeleteChatResponse
+from ..model.get_chat_request import GetChatRequest
+from ..model.get_chat_response import GetChatResponse
+from ..model.link_chat_request import LinkChatRequest
+from ..model.link_chat_response import LinkChatResponse
+from ..model.list_chat_request import ListChatRequest
+from ..model.list_chat_response import ListChatResponse
+from ..model.search_chat_request import SearchChatRequest
+from ..model.search_chat_response import SearchChatResponse
+from ..model.update_chat_request import UpdateChatRequest
+from ..model.update_chat_response import UpdateChatResponse
+
+
+class Chat(object):
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+
+    def create(self, request: CreateChatRequest, option: Optional[RequestOption] = None) -> CreateChatResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: CreateChatResponse = JSON.unmarshal(str(resp.content, UTF_8), CreateChatResponse)
+        response.raw = resp
+
+        return response
+
+    async def acreate(self, request: CreateChatRequest, option: Optional[RequestOption] = None) -> CreateChatResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: CreateChatResponse = JSON.unmarshal(str(resp.content, UTF_8), CreateChatResponse)
+        response.raw = resp
+
+        return response
+
+    def delete(self, request: DeleteChatRequest, option: Optional[RequestOption] = None) -> DeleteChatResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: DeleteChatResponse = JSON.unmarshal(str(resp.content, UTF_8), DeleteChatResponse)
+        response.raw = resp
+
+        return response
+
+    async def adelete(self, request: DeleteChatRequest, option: Optional[RequestOption] = None) -> DeleteChatResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: DeleteChatResponse = JSON.unmarshal(str(resp.content, UTF_8), DeleteChatResponse)
+        response.raw = resp
+
+        return response
+
+    def get(self, request: GetChatRequest, option: Optional[RequestOption] = None) -> GetChatResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: GetChatResponse = JSON.unmarshal(str(resp.content, UTF_8), GetChatResponse)
+        response.raw = resp
+
+        return response
+
+    async def aget(self, request: GetChatRequest, option: Optional[RequestOption] = None) -> GetChatResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: GetChatResponse = JSON.unmarshal(str(resp.content, UTF_8), GetChatResponse)
+        response.raw = resp
+
+        return response
+
+    def link(self, request: LinkChatRequest, option: Optional[RequestOption] = None) -> LinkChatResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: LinkChatResponse = JSON.unmarshal(str(resp.content, UTF_8), LinkChatResponse)
+        response.raw = resp
+
+        return response
+
+    async def alink(self, request: LinkChatRequest, option: Optional[RequestOption] = None) -> LinkChatResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: LinkChatResponse = JSON.unmarshal(str(resp.content, UTF_8), LinkChatResponse)
+        response.raw = resp
+
+        return response
+
+    def list(self, request: ListChatRequest, option: Optional[RequestOption] = None) -> ListChatResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: ListChatResponse = JSON.unmarshal(str(resp.content, UTF_8), ListChatResponse)
+        response.raw = resp
+
+        return response
+
+    async def alist(self, request: ListChatRequest, option: Optional[RequestOption] = None) -> ListChatResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: ListChatResponse = JSON.unmarshal(str(resp.content, UTF_8), ListChatResponse)
+        response.raw = resp
+
+        return response
+
+    def search(self, request: SearchChatRequest, option: Optional[RequestOption] = None) -> SearchChatResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: SearchChatResponse = JSON.unmarshal(str(resp.content, UTF_8), SearchChatResponse)
+        response.raw = resp
+
+        return response
+
+    async def asearch(self, request: SearchChatRequest, option: Optional[RequestOption] = None) -> SearchChatResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: SearchChatResponse = JSON.unmarshal(str(resp.content, UTF_8), SearchChatResponse)
+        response.raw = resp
+
+        return response
+
+    def update(self, request: UpdateChatRequest, option: Optional[RequestOption] = None) -> UpdateChatResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: UpdateChatResponse = JSON.unmarshal(str(resp.content, UTF_8), UpdateChatResponse)
+        response.raw = resp
+
+        return response
+
+    async def aupdate(self, request: UpdateChatRequest, option: Optional[RequestOption] = None) -> UpdateChatResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: UpdateChatResponse = JSON.unmarshal(str(resp.content, UTF_8), UpdateChatResponse)
+        response.raw = resp
+
+        return response
diff --git a/lark_channel/api/im/v1/resource/file.py b/lark_channel/api/im/v1/resource/file.py
new file mode 100644
index 0000000..daaf7b9
--- /dev/null
+++ b/lark_channel/api/im/v1/resource/file.py
@@ -0,0 +1,109 @@
+import io
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.const import UTF_8, CONTENT_TYPE, APPLICATION_JSON
+from lark_channel.core import JSON
+from lark_channel.core.token import verify
+from lark_channel.core.http import Transport
+from lark_channel.core.model import Config, RequestOption, RawResponse
+from lark_channel.core.utils import Files
+from requests_toolbelt import MultipartEncoder
+from ..model.create_file_request import CreateFileRequest
+from ..model.create_file_response import CreateFileResponse
+from ..model.get_file_request import GetFileRequest
+from ..model.get_file_response import GetFileResponse
+
+
+class File(object):
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+
+    def create(self, request: CreateFileRequest, option: Optional[RequestOption] = None) -> CreateFileResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            form_data = MultipartEncoder(Files.parse_form_data(request.body))
+            request.body = form_data
+            option.headers[CONTENT_TYPE] = form_data.content_type
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: CreateFileResponse = JSON.unmarshal(str(resp.content, UTF_8), CreateFileResponse)
+        response.raw = resp
+
+        return response
+
+    async def acreate(self, request: CreateFileRequest, option: Optional[RequestOption] = None) -> CreateFileResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Parse the file
+        request.files = Files.extract_files(request.body)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: CreateFileResponse = JSON.unmarshal(str(resp.content, UTF_8), CreateFileResponse)
+        response.raw = resp
+
+        return response
+
+    def get(self, request: GetFileRequest, option: Optional[RequestOption] = None) -> GetFileResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Handle the binary stream
+        content_type = resp.headers.get(CONTENT_TYPE)
+        response: GetFileResponse = GetFileResponse()
+        if 200 <= resp.status_code < 300:
+            response.code = 0
+            response.file = io.BytesIO(resp.content)
+            response.file_name = Files.parse_file_name(resp.headers)
+        elif content_type is not None and content_type.startswith(APPLICATION_JSON):
+            response = JSON.unmarshal(str(resp.content, UTF_8), GetFileResponse)
+
+        response.raw = resp
+        return response
+
+    async def aget(self, request: GetFileRequest, option: Optional[RequestOption] = None) -> GetFileResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Handle the binary stream
+        content_type = resp.headers.get(CONTENT_TYPE)
+        response: GetFileResponse = GetFileResponse()
+        if 200 <= resp.status_code < 300:
+            response.code = 0
+            response.file = io.BytesIO(resp.content)
+            response.file_name = Files.parse_file_name(resp.headers)
+        elif content_type is not None and content_type.startswith(APPLICATION_JSON):
+            response = JSON.unmarshal(str(resp.content, UTF_8), GetFileResponse)
+
+        response.raw = resp
+        return response
diff --git a/lark_channel/api/im/v1/resource/image.py b/lark_channel/api/im/v1/resource/image.py
new file mode 100644
index 0000000..f805648
--- /dev/null
+++ b/lark_channel/api/im/v1/resource/image.py
@@ -0,0 +1,109 @@
+import io
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.const import UTF_8, CONTENT_TYPE, APPLICATION_JSON
+from lark_channel.core import JSON
+from lark_channel.core.token import verify
+from lark_channel.core.http import Transport
+from lark_channel.core.model import Config, RequestOption, RawResponse
+from lark_channel.core.utils import Files
+from requests_toolbelt import MultipartEncoder
+from ..model.create_image_request import CreateImageRequest
+from ..model.create_image_response import CreateImageResponse
+from ..model.get_image_request import GetImageRequest
+from ..model.get_image_response import GetImageResponse
+
+
+class Image(object):
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+
+    def create(self, request: CreateImageRequest, option: Optional[RequestOption] = None) -> CreateImageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            form_data = MultipartEncoder(Files.parse_form_data(request.body))
+            request.body = form_data
+            option.headers[CONTENT_TYPE] = form_data.content_type
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: CreateImageResponse = JSON.unmarshal(str(resp.content, UTF_8), CreateImageResponse)
+        response.raw = resp
+
+        return response
+
+    async def acreate(self, request: CreateImageRequest, option: Optional[RequestOption] = None) -> CreateImageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Parse the file
+        request.files = Files.extract_files(request.body)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: CreateImageResponse = JSON.unmarshal(str(resp.content, UTF_8), CreateImageResponse)
+        response.raw = resp
+
+        return response
+
+    def get(self, request: GetImageRequest, option: Optional[RequestOption] = None) -> GetImageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Handle the binary stream
+        content_type = resp.headers.get(CONTENT_TYPE)
+        response: GetImageResponse = GetImageResponse()
+        if 200 <= resp.status_code < 300:
+            response.code = 0
+            response.file = io.BytesIO(resp.content)
+            response.file_name = Files.parse_file_name(resp.headers)
+        elif content_type is not None and content_type.startswith(APPLICATION_JSON):
+            response = JSON.unmarshal(str(resp.content, UTF_8), GetImageResponse)
+
+        response.raw = resp
+        return response
+
+    async def aget(self, request: GetImageRequest, option: Optional[RequestOption] = None) -> GetImageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Handle the binary stream
+        content_type = resp.headers.get(CONTENT_TYPE)
+        response: GetImageResponse = GetImageResponse()
+        if 200 <= resp.status_code < 300:
+            response.code = 0
+            response.file = io.BytesIO(resp.content)
+            response.file_name = Files.parse_file_name(resp.headers)
+        elif content_type is not None and content_type.startswith(APPLICATION_JSON):
+            response = JSON.unmarshal(str(resp.content, UTF_8), GetImageResponse)
+
+        response.raw = resp
+        return response
diff --git a/lark_channel/api/im/v1/resource/message.py b/lark_channel/api/im/v1/resource/message.py
new file mode 100644
index 0000000..ce0af81
--- /dev/null
+++ b/lark_channel/api/im/v1/resource/message.py
@@ -0,0 +1,564 @@
+import io
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.const import UTF_8, CONTENT_TYPE, APPLICATION_JSON
+from lark_channel.core import JSON
+from lark_channel.core.token import verify
+from lark_channel.core.http import Transport
+from lark_channel.core.model import Config, RequestOption, RawResponse
+from lark_channel.core.utils import Files
+from requests_toolbelt import MultipartEncoder
+from ..model.create_message_request import CreateMessageRequest
+from ..model.create_message_response import CreateMessageResponse
+from ..model.delete_message_request import DeleteMessageRequest
+from ..model.delete_message_response import DeleteMessageResponse
+from ..model.forward_message_request import ForwardMessageRequest
+from ..model.forward_message_response import ForwardMessageResponse
+from ..model.get_message_request import GetMessageRequest
+from ..model.get_message_response import GetMessageResponse
+from ..model.list_message_request import ListMessageRequest
+from ..model.list_message_response import ListMessageResponse
+from ..model.merge_forward_message_request import MergeForwardMessageRequest
+from ..model.merge_forward_message_response import MergeForwardMessageResponse
+from ..model.patch_message_request import PatchMessageRequest
+from ..model.patch_message_response import PatchMessageResponse
+from ..model.push_follow_up_message_request import PushFollowUpMessageRequest
+from ..model.push_follow_up_message_response import PushFollowUpMessageResponse
+from ..model.read_users_message_request import ReadUsersMessageRequest
+from ..model.read_users_message_response import ReadUsersMessageResponse
+from ..model.reply_message_request import ReplyMessageRequest
+from ..model.reply_message_response import ReplyMessageResponse
+from ..model.update_message_request import UpdateMessageRequest
+from ..model.update_message_response import UpdateMessageResponse
+from ..model.urgent_app_message_request import UrgentAppMessageRequest
+from ..model.urgent_app_message_response import UrgentAppMessageResponse
+from ..model.urgent_phone_message_request import UrgentPhoneMessageRequest
+from ..model.urgent_phone_message_response import UrgentPhoneMessageResponse
+from ..model.urgent_sms_message_request import UrgentSmsMessageRequest
+from ..model.urgent_sms_message_response import UrgentSmsMessageResponse
+
+
+class Message(object):
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+
+    def create(self, request: CreateMessageRequest, option: Optional[RequestOption] = None) -> CreateMessageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: CreateMessageResponse = JSON.unmarshal(str(resp.content, UTF_8), CreateMessageResponse)
+        response.raw = resp
+
+        return response
+
+    async def acreate(self, request: CreateMessageRequest,
+                      option: Optional[RequestOption] = None) -> CreateMessageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: CreateMessageResponse = JSON.unmarshal(str(resp.content, UTF_8), CreateMessageResponse)
+        response.raw = resp
+
+        return response
+
+    def delete(self, request: DeleteMessageRequest, option: Optional[RequestOption] = None) -> DeleteMessageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: DeleteMessageResponse = JSON.unmarshal(str(resp.content, UTF_8), DeleteMessageResponse)
+        response.raw = resp
+
+        return response
+
+    async def adelete(self, request: DeleteMessageRequest,
+                      option: Optional[RequestOption] = None) -> DeleteMessageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: DeleteMessageResponse = JSON.unmarshal(str(resp.content, UTF_8), DeleteMessageResponse)
+        response.raw = resp
+
+        return response
+
+    def forward(self, request: ForwardMessageRequest, option: Optional[RequestOption] = None) -> ForwardMessageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: ForwardMessageResponse = JSON.unmarshal(str(resp.content, UTF_8), ForwardMessageResponse)
+        response.raw = resp
+
+        return response
+
+    async def aforward(self, request: ForwardMessageRequest,
+                       option: Optional[RequestOption] = None) -> ForwardMessageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: ForwardMessageResponse = JSON.unmarshal(str(resp.content, UTF_8), ForwardMessageResponse)
+        response.raw = resp
+
+        return response
+
+    def get(self, request: GetMessageRequest, option: Optional[RequestOption] = None) -> GetMessageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: GetMessageResponse = JSON.unmarshal(str(resp.content, UTF_8), GetMessageResponse)
+        response.raw = resp
+
+        return response
+
+    async def aget(self, request: GetMessageRequest, option: Optional[RequestOption] = None) -> GetMessageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: GetMessageResponse = JSON.unmarshal(str(resp.content, UTF_8), GetMessageResponse)
+        response.raw = resp
+
+        return response
+
+    def list(self, request: ListMessageRequest, option: Optional[RequestOption] = None) -> ListMessageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: ListMessageResponse = JSON.unmarshal(str(resp.content, UTF_8), ListMessageResponse)
+        response.raw = resp
+
+        return response
+
+    async def alist(self, request: ListMessageRequest, option: Optional[RequestOption] = None) -> ListMessageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: ListMessageResponse = JSON.unmarshal(str(resp.content, UTF_8), ListMessageResponse)
+        response.raw = resp
+
+        return response
+
+    def merge_forward(self, request: MergeForwardMessageRequest,
+                      option: Optional[RequestOption] = None) -> MergeForwardMessageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: MergeForwardMessageResponse = JSON.unmarshal(str(resp.content, UTF_8), MergeForwardMessageResponse)
+        response.raw = resp
+
+        return response
+
+    async def amerge_forward(self, request: MergeForwardMessageRequest,
+                             option: Optional[RequestOption] = None) -> MergeForwardMessageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: MergeForwardMessageResponse = JSON.unmarshal(str(resp.content, UTF_8), MergeForwardMessageResponse)
+        response.raw = resp
+
+        return response
+
+    def patch(self, request: PatchMessageRequest, option: Optional[RequestOption] = None) -> PatchMessageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: PatchMessageResponse = JSON.unmarshal(str(resp.content, UTF_8), PatchMessageResponse)
+        response.raw = resp
+
+        return response
+
+    async def apatch(self, request: PatchMessageRequest,
+                     option: Optional[RequestOption] = None) -> PatchMessageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: PatchMessageResponse = JSON.unmarshal(str(resp.content, UTF_8), PatchMessageResponse)
+        response.raw = resp
+
+        return response
+
+    def push_follow_up(self, request: PushFollowUpMessageRequest,
+                       option: Optional[RequestOption] = None) -> PushFollowUpMessageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: PushFollowUpMessageResponse = JSON.unmarshal(str(resp.content, UTF_8), PushFollowUpMessageResponse)
+        response.raw = resp
+
+        return response
+
+    async def apush_follow_up(self, request: PushFollowUpMessageRequest,
+                              option: Optional[RequestOption] = None) -> PushFollowUpMessageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: PushFollowUpMessageResponse = JSON.unmarshal(str(resp.content, UTF_8), PushFollowUpMessageResponse)
+        response.raw = resp
+
+        return response
+
+    def read_users(self, request: ReadUsersMessageRequest,
+                   option: Optional[RequestOption] = None) -> ReadUsersMessageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: ReadUsersMessageResponse = JSON.unmarshal(str(resp.content, UTF_8), ReadUsersMessageResponse)
+        response.raw = resp
+
+        return response
+
+    async def aread_users(self, request: ReadUsersMessageRequest,
+                          option: Optional[RequestOption] = None) -> ReadUsersMessageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: ReadUsersMessageResponse = JSON.unmarshal(str(resp.content, UTF_8), ReadUsersMessageResponse)
+        response.raw = resp
+
+        return response
+
+    def reply(self, request: ReplyMessageRequest, option: Optional[RequestOption] = None) -> ReplyMessageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: ReplyMessageResponse = JSON.unmarshal(str(resp.content, UTF_8), ReplyMessageResponse)
+        response.raw = resp
+
+        return response
+
+    async def areply(self, request: ReplyMessageRequest,
+                     option: Optional[RequestOption] = None) -> ReplyMessageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: ReplyMessageResponse = JSON.unmarshal(str(resp.content, UTF_8), ReplyMessageResponse)
+        response.raw = resp
+
+        return response
+
+    def update(self, request: UpdateMessageRequest, option: Optional[RequestOption] = None) -> UpdateMessageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: UpdateMessageResponse = JSON.unmarshal(str(resp.content, UTF_8), UpdateMessageResponse)
+        response.raw = resp
+
+        return response
+
+    async def aupdate(self, request: UpdateMessageRequest,
+                      option: Optional[RequestOption] = None) -> UpdateMessageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: UpdateMessageResponse = JSON.unmarshal(str(resp.content, UTF_8), UpdateMessageResponse)
+        response.raw = resp
+
+        return response
+
+    def urgent_app(self, request: UrgentAppMessageRequest,
+                   option: Optional[RequestOption] = None) -> UrgentAppMessageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: UrgentAppMessageResponse = JSON.unmarshal(str(resp.content, UTF_8), UrgentAppMessageResponse)
+        response.raw = resp
+
+        return response
+
+    async def aurgent_app(self, request: UrgentAppMessageRequest,
+                          option: Optional[RequestOption] = None) -> UrgentAppMessageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: UrgentAppMessageResponse = JSON.unmarshal(str(resp.content, UTF_8), UrgentAppMessageResponse)
+        response.raw = resp
+
+        return response
+
+    def urgent_phone(self, request: UrgentPhoneMessageRequest,
+                     option: Optional[RequestOption] = None) -> UrgentPhoneMessageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: UrgentPhoneMessageResponse = JSON.unmarshal(str(resp.content, UTF_8), UrgentPhoneMessageResponse)
+        response.raw = resp
+
+        return response
+
+    async def aurgent_phone(self, request: UrgentPhoneMessageRequest,
+                            option: Optional[RequestOption] = None) -> UrgentPhoneMessageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: UrgentPhoneMessageResponse = JSON.unmarshal(str(resp.content, UTF_8), UrgentPhoneMessageResponse)
+        response.raw = resp
+
+        return response
+
+    def urgent_sms(self, request: UrgentSmsMessageRequest,
+                   option: Optional[RequestOption] = None) -> UrgentSmsMessageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: UrgentSmsMessageResponse = JSON.unmarshal(str(resp.content, UTF_8), UrgentSmsMessageResponse)
+        response.raw = resp
+
+        return response
+
+    async def aurgent_sms(self, request: UrgentSmsMessageRequest,
+                          option: Optional[RequestOption] = None) -> UrgentSmsMessageResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: UrgentSmsMessageResponse = JSON.unmarshal(str(resp.content, UTF_8), UrgentSmsMessageResponse)
+        response.raw = resp
+
+        return response
diff --git a/lark_channel/api/im/v1/resource/message_reaction.py b/lark_channel/api/im/v1/resource/message_reaction.py
new file mode 100644
index 0000000..dbcace3
--- /dev/null
+++ b/lark_channel/api/im/v1/resource/message_reaction.py
@@ -0,0 +1,138 @@
+import io
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.const import UTF_8, CONTENT_TYPE, APPLICATION_JSON
+from lark_channel.core import JSON
+from lark_channel.core.token import verify
+from lark_channel.core.http import Transport
+from lark_channel.core.model import Config, RequestOption, RawResponse
+from lark_channel.core.utils import Files
+from requests_toolbelt import MultipartEncoder
+from ..model.create_message_reaction_request import CreateMessageReactionRequest
+from ..model.create_message_reaction_response import CreateMessageReactionResponse
+from ..model.delete_message_reaction_request import DeleteMessageReactionRequest
+from ..model.delete_message_reaction_response import DeleteMessageReactionResponse
+from ..model.list_message_reaction_request import ListMessageReactionRequest
+from ..model.list_message_reaction_response import ListMessageReactionResponse
+
+
+class MessageReaction(object):
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+
+    def create(self, request: CreateMessageReactionRequest,
+               option: Optional[RequestOption] = None) -> CreateMessageReactionResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: CreateMessageReactionResponse = JSON.unmarshal(str(resp.content, UTF_8),
+                                                                 CreateMessageReactionResponse)
+        response.raw = resp
+
+        return response
+
+    async def acreate(self, request: CreateMessageReactionRequest,
+                      option: Optional[RequestOption] = None) -> CreateMessageReactionResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: CreateMessageReactionResponse = JSON.unmarshal(str(resp.content, UTF_8),
+                                                                 CreateMessageReactionResponse)
+        response.raw = resp
+
+        return response
+
+    def delete(self, request: DeleteMessageReactionRequest,
+               option: Optional[RequestOption] = None) -> DeleteMessageReactionResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: DeleteMessageReactionResponse = JSON.unmarshal(str(resp.content, UTF_8),
+                                                                 DeleteMessageReactionResponse)
+        response.raw = resp
+
+        return response
+
+    async def adelete(self, request: DeleteMessageReactionRequest,
+                      option: Optional[RequestOption] = None) -> DeleteMessageReactionResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: DeleteMessageReactionResponse = JSON.unmarshal(str(resp.content, UTF_8),
+                                                                 DeleteMessageReactionResponse)
+        response.raw = resp
+
+        return response
+
+    def list(self, request: ListMessageReactionRequest,
+             option: Optional[RequestOption] = None) -> ListMessageReactionResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Deserialize the response
+        response: ListMessageReactionResponse = JSON.unmarshal(str(resp.content, UTF_8), ListMessageReactionResponse)
+        response.raw = resp
+
+        return response
+
+    async def alist(self, request: ListMessageReactionRequest,
+                    option: Optional[RequestOption] = None) -> ListMessageReactionResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Deserialize the response
+        response: ListMessageReactionResponse = JSON.unmarshal(str(resp.content, UTF_8), ListMessageReactionResponse)
+        response.raw = resp
+
+        return response
diff --git a/lark_channel/api/im/v1/resource/message_resource.py b/lark_channel/api/im/v1/resource/message_resource.py
new file mode 100644
index 0000000..600a318
--- /dev/null
+++ b/lark_channel/api/im/v1/resource/message_resource.py
@@ -0,0 +1,68 @@
+import io
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.const import UTF_8, CONTENT_TYPE, APPLICATION_JSON
+from lark_channel.core import JSON
+from lark_channel.core.token import verify
+from lark_channel.core.http import Transport
+from lark_channel.core.model import Config, RequestOption, RawResponse
+from lark_channel.core.utils import Files
+from requests_toolbelt import MultipartEncoder
+from ..model.get_message_resource_request import GetMessageResourceRequest
+from ..model.get_message_resource_response import GetMessageResourceResponse
+
+
+class MessageResource(object):
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+
+    def get(self, request: GetMessageResourceRequest,
+            option: Optional[RequestOption] = None) -> GetMessageResourceResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Add content-type
+        if request.body is not None:
+            option.headers[CONTENT_TYPE] = f"{APPLICATION_JSON}; charset=utf-8"
+
+        # Send the request
+        resp: RawResponse = Transport.execute(self.config, request, option)
+
+        # Handle the binary stream
+        content_type = resp.headers.get(CONTENT_TYPE)
+        response: GetMessageResourceResponse = GetMessageResourceResponse()
+        if 200 <= resp.status_code < 300:
+            response.code = 0
+            response.file = io.BytesIO(resp.content)
+            response.file_name = Files.parse_file_name(resp.headers)
+        elif content_type is not None and content_type.startswith(APPLICATION_JSON):
+            response = JSON.unmarshal(str(resp.content, UTF_8), GetMessageResourceResponse)
+
+        response.raw = resp
+        return response
+
+    async def aget(self, request: GetMessageResourceRequest,
+                   option: Optional[RequestOption] = None) -> GetMessageResourceResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Authenticate and obtain a token
+        verify(self.config, request, option)
+
+        # Send the request
+        resp: RawResponse = await Transport.aexecute(self.config, request, option)
+
+        # Handle the binary stream
+        content_type = resp.headers.get(CONTENT_TYPE)
+        response: GetMessageResourceResponse = GetMessageResourceResponse()
+        if 200 <= resp.status_code < 300:
+            response.code = 0
+            response.file = io.BytesIO(resp.content)
+            response.file_name = Files.parse_file_name(resp.headers)
+        elif content_type is not None and content_type.startswith(APPLICATION_JSON):
+            response = JSON.unmarshal(str(resp.content, UTF_8), GetMessageResourceResponse)
+
+        response.raw = resp
+        return response
diff --git a/lark_channel/api/im/v1/version.py b/lark_channel/api/im/v1/version.py
new file mode 100644
index 0000000..4ccdfba
--- /dev/null
+++ b/lark_channel/api/im/v1/version.py
@@ -0,0 +1,13 @@
+from lark_channel.core.model import Config
+
+from .resource import Chat, File, Image, Message, MessageReaction, MessageResource
+
+
+class V1(object):
+    def __init__(self, config: Config) -> None:
+        self.chat: Chat = Chat(config)
+        self.file: File = File(config)
+        self.image: Image = Image(config)
+        self.message: Message = Message(config)
+        self.message_reaction: MessageReaction = MessageReaction(config)
+        self.message_resource: MessageResource = MessageResource(config)
diff --git a/lark_channel/api/wiki/__init__.py b/lark_channel/api/wiki/__init__.py
new file mode 100644
index 0000000..ec73528
--- /dev/null
+++ b/lark_channel/api/wiki/__init__.py
@@ -0,0 +1 @@
+"""Minimal Wiki primitives required by lark_channel."""
diff --git a/lark_channel/api/wiki/node.py b/lark_channel/api/wiki/node.py
new file mode 100644
index 0000000..34faeda
--- /dev/null
+++ b/lark_channel/api/wiki/node.py
@@ -0,0 +1,11 @@
+from lark_channel.core.enum import AccessTokenType, HttpMethod
+from lark_channel.core.model import BaseRequest
+
+
+def build_wiki_node_get_request(*, token: str) -> BaseRequest:
+    req = BaseRequest()
+    req.http_method = HttpMethod.GET
+    req.uri = "/open-apis/wiki/v2/spaces/get_node"
+    req.token_types = {AccessTokenType.TENANT, AccessTokenType.USER}
+    req.add_query("token", token)
+    return req
diff --git a/lark_channel/card/__init__.py b/lark_channel/card/__init__.py
new file mode 100644
index 0000000..00c2159
--- /dev/null
+++ b/lark_channel/card/__init__.py
@@ -0,0 +1,2 @@
+from .action_handler import CardActionHandler
+from .model import *
diff --git a/lark_channel/card/action_handler.py b/lark_channel/card/action_handler.py
new file mode 100644
index 0000000..4dd556c
--- /dev/null
+++ b/lark_channel/card/action_handler.py
@@ -0,0 +1,262 @@
+import hashlib
+import hmac
+import json
+import logging
+from typing import Optional, Callable, Any, TYPE_CHECKING
+
+from lark_channel.core.const import *
+from lark_channel.core.enum import LogLevel
+from lark_channel.core.exception import InvalidArgsException, AccessDeniedException, CardException, \
+    NoAuthorizationException
+from lark_channel.core.http import HttpHandler
+from lark_channel.core.json import JSON
+from lark_channel.core.log import logger, redact_for_log
+from lark_channel.core.model import RawRequest, RawResponse
+from lark_channel.core.utils import Strings, AESCipher
+from lark_channel.event.security import (
+    REASON_CARD_SIGNATURE_INVALID,
+    REASON_CARD_SIGNATURE_MISSING,
+    build_error_response_content,
+    should_record_security_audit,
+)
+from .model import Card
+
+if TYPE_CHECKING:
+    from lark_channel.channel.config import SecurityConfig
+
+
+class CardActionHandler(HttpHandler):
+
+    def __init__(self, security: Optional["SecurityConfig"] = None) -> None:
+        self._encrypt_key: Optional[str] = None
+        self._verification_token: Optional[str] = None
+        self._processor: Optional[Callable[[Card], Any]] = None
+        self._security = security or _default_security_config()
+
+    def do(self, req: RawRequest) -> RawResponse:
+        if logger.isEnabledFor(logging.DEBUG):
+            logger.debug(f"card access, uri: {req.uri}, "
+                         f"headers: {JSON.marshal(redact_for_log(req.headers))}, "
+                         f"body: {JSON.marshal(redact_for_log(req.body)) if req.body is not None else None}")
+
+        resp = RawResponse()
+        resp.status_code = 200
+        resp.set_content_type(f"{APPLICATION_JSON}; charset=utf-8")
+
+        try:
+            if req.body is None:
+                raise InvalidArgsException("request body is null")
+
+            signature_preverified = False
+            if self._is_encrypted_payload(req.body):
+                signature_preverified = self._preverify_encrypted_request(req)
+
+            # Decrypt the message
+            plaintext = self._decrypt(req.body)
+
+            # Deserialize the response
+            card = JSON.unmarshal(plaintext, Card)
+            card.raw = req
+
+            if URL_VERIFICATION == card.type:
+                # URL verification: constant-time token compare.
+                if self._verification_token is None or card.token is None or not hmac.compare_digest(
+                    self._verification_token, card.token
+                ):
+                    raise AccessDeniedException("invalid verification_token")
+
+                # Echo the challenge (JSON-escaped).
+                resp.content = JSON.marshal({"challenge": card.challenge}).encode(UTF_8)
+                return resp
+            else:
+                # Otherwise verify the signature
+                if not signature_preverified:
+                    self._verify_sign(req)
+
+            if self._processor is None:
+                raise CardException("processor not found")
+
+            # Handle the business logic
+            result: Any = self._processor(card)
+
+            # Return the result
+            if result is None:
+                resp.content = "{\"msg\":\"success\"}".encode(UTF_8)
+            elif isinstance(result, bytes):
+                resp.content = result
+            elif isinstance(result, str):
+                resp.content = bytes(result, UTF_8)
+            elif isinstance(result, RawResponse):
+                resp = result
+            else:
+                resp.content = JSON.marshal(result).encode(UTF_8)
+
+            return resp
+
+        except Exception as e:
+            if self._security.enforce_strict_error_response:
+                logger.error(
+                    "handle card failed, uri: %s, request_id: %s, err: %s",
+                    req.uri,
+                    req.headers.get(X_REQUEST_ID),
+                    redact_for_log(str(e)),
+                )
+            else:
+                logger.exception(
+                    f"handle card failed, uri: {req.uri}, request_id: {req.headers.get(X_REQUEST_ID)}, err: {e}")
+            resp.status_code = 500
+            resp.content = build_error_response_content(e, security=self._security)
+
+            return resp
+
+    def _decrypt(self, content: bytes) -> str:
+        plaintext: str
+        encrypt = json.loads(content).get("encrypt")
+        if Strings.is_not_empty(encrypt):
+            if Strings.is_empty(self._encrypt_key):
+                raise NoAuthorizationException("encrypt_key not found")
+            plaintext = AESCipher(self._encrypt_key).decrypt_str(encrypt)
+        else:
+            plaintext = str(content, UTF_8)
+
+        return plaintext
+
+    def _is_encrypted_payload(self, content: bytes) -> bool:
+        try:
+            encrypt = json.loads(content).get("encrypt")
+        except (TypeError, ValueError, AttributeError):
+            return False
+        return Strings.is_not_empty(encrypt)
+
+    def _preverify_encrypted_request(self, request: RawRequest) -> bool:
+        if Strings.is_empty(self._verification_token):
+            if (
+                self._security.is_strict
+                and not self._security.allow_unsigned_encrypted_webhook
+            ):
+                self._record_security_audit(
+                    REASON_CARD_SIGNATURE_MISSING,
+                    action="block",
+                    request=request,
+                )
+                raise AccessDeniedException("signature verification failed")
+            if self._security.is_strict:
+                self._record_security_audit(
+                    REASON_CARD_SIGNATURE_MISSING,
+                    action="allow",
+                    request=request,
+                )
+            return False
+        if not self._has_signature_headers(request):
+            action = "legacy_flow"
+            if self._security.is_strict:
+                action = (
+                    "allow"
+                    if self._security.allow_unsigned_encrypted_webhook
+                    else "block"
+                )
+            self._record_security_audit(
+                REASON_CARD_SIGNATURE_MISSING,
+                action=action,
+                request=request,
+            )
+            if (
+                self._security.is_strict
+                and not self._security.allow_unsigned_encrypted_webhook
+            ):
+                raise AccessDeniedException("signature verification failed")
+            return True
+        try:
+            self._verify_sign(request)
+        except Exception:
+            self._record_security_audit(
+                REASON_CARD_SIGNATURE_INVALID,
+                action="block",
+                request=request,
+            )
+            raise
+        return True
+
+    def _has_signature_headers(self, request: RawRequest) -> bool:
+        return (
+            Strings.is_not_empty(request.headers.get(LARK_REQUEST_TIMESTAMP))
+            and Strings.is_not_empty(request.headers.get(LARK_REQUEST_NONCE))
+            and Strings.is_not_empty(request.headers.get(LARK_REQUEST_SIGNATURE))
+        )
+
+    def _record_security_audit(
+        self,
+        reason: str,
+        *,
+        action: str,
+        request: RawRequest,
+    ) -> None:
+        if not should_record_security_audit(self._security):
+            return
+        self._security.audit_recorder.record(
+            reason,
+            mode=self._security.mode,
+            action=action,
+            details={
+                "uri": request.uri,
+                "request_id": request.headers.get(X_REQUEST_ID),
+            },
+        )
+
+    def _verify_sign(self, request: RawRequest) -> None:
+        if self._verification_token is None or self._verification_token == "":
+            return
+        timestamp = request.headers.get(LARK_REQUEST_TIMESTAMP)
+        nonce = request.headers.get(LARK_REQUEST_NONCE)
+        signature = request.headers.get(LARK_REQUEST_SIGNATURE)
+        bs = (timestamp + nonce + self._verification_token).encode(UTF_8) + request.body
+        h = hashlib.sha1(bs)
+        if signature != h.hexdigest():
+            raise AccessDeniedException("signature verification failed")
+
+    @staticmethod
+    def builder(
+        encrypt_key: str,
+        verification_token: str,
+        level: LogLevel = None,
+        *,
+        security: Optional["SecurityConfig"] = None,
+    ) -> "CardActionHandlerBuilder":
+        if level is not None:
+            logger.setLevel(int(level.value))
+        return CardActionHandlerBuilder(
+            encrypt_key,
+            verification_token,
+            security=security,
+        )
+
+
+class CardActionHandlerBuilder(object):
+    def __init__(
+        self,
+        encrypt_key: str,
+        verification_token: str,
+        *,
+        security: Optional["SecurityConfig"] = None,
+    ) -> None:
+        self._encrypt_key = encrypt_key
+        self._verification_token = verification_token
+        self._processor: Optional[Callable[[Card], Any]] = None
+        self._security = security or _default_security_config()
+
+    def register(self, f: Callable[[Card], Any]) -> "CardActionHandlerBuilder":
+        self._processor = f
+        return self
+
+    def build(self) -> CardActionHandler:
+        card_action_handler = CardActionHandler(security=self._security)
+        card_action_handler._encrypt_key = self._encrypt_key
+        card_action_handler._verification_token = self._verification_token
+        card_action_handler._processor = self._processor
+        return card_action_handler
+
+
+def _default_security_config():
+    from lark_channel.channel.config import SecurityConfig
+
+    return SecurityConfig()
diff --git a/lark_channel/card/model.py b/lark_channel/card/model.py
new file mode 100644
index 0000000..b606e82
--- /dev/null
+++ b/lark_channel/card/model.py
@@ -0,0 +1,39 @@
+from typing import Dict, Optional, Any, List
+
+from lark_channel.core.construct import init
+from lark_channel.core.model import RawRequest
+
+
+class Action(object):
+    _types = {}
+
+    def __init__(self, d=None) -> None:
+        self.value: Dict[str, Any] = {}
+        self.tag: Optional[str] = None
+        self.option: Optional[str] = None
+        self.timezone: Optional[str] = None
+        self.name: Optional[str] = None
+        self.form_value: Dict[str, Any] = {}
+        self.input_value: Optional[str] = None
+        self.options: Optional[List[str]] = []
+        self.checked: Optional[bool] = None
+        init(self, d, self._types)
+
+
+class Card(object):
+    _types = {
+        "action": Action
+    }
+
+    def __init__(self, d=None) -> None:
+        self.open_id: Optional[str] = None
+        self.user_id: Optional[str] = None
+        self.tenant_key: Optional[str] = None
+        self.open_message_id: Optional[str] = None
+        self.open_chat_id: Optional[str] = None
+        self.token: Optional[str] = None
+        self.challenge: Optional[str] = None
+        self.type: Optional[str] = None
+        self.action: Optional[Action] = None
+        self.raw: Optional[RawRequest] = None
+        init(self, d, self._types)
diff --git a/lark_channel/channel/__init__.py b/lark_channel/channel/__init__.py
new file mode 100644
index 0000000..5af8bea
--- /dev/null
+++ b/lark_channel/channel/__init__.py
@@ -0,0 +1,339 @@
+"""lark_channel.channel — high-level Feishu Channel capability layer.
+
+Typical usage::
+
+    import asyncio
+    from lark_channel import FeishuChannel
+
+    channel = FeishuChannel(app_id="cli_xxx", app_secret="***")
+
+    async def on_message(msg):
+        await channel.send(msg.conversation.chat_id, {"text": f"echo: {msg.content_text}"})
+
+    channel.on("message", on_message)
+
+    asyncio.run(channel.connect())
+
+The public surface is organized around :class:`FeishuChannel`. All events fire
+through ``channel.on(event_name, handler)``; all sends/updates go through
+explicit channel methods (``send`` / ``stream`` / ``update_card`` / ...).
+"""
+
+from .auth import (
+    DeviceFlowClient,
+    DeviceFlowInit,
+    FileTokenStore,
+    InMemoryTokenStore,
+    TokenStore,
+)
+from .bot_identity import BotIdentity, fetch_bot_identity
+from .card import CardBuilder, new_card
+from .channel import FeishuChannel
+from .config import (
+    ChannelConfig,
+    ChatModeCacheConfig,
+    ChatQueueConfig,
+    DedupConfig,
+    DmPolicy,
+    FooterConfig,
+    GroupOverride,
+    GroupPolicy,
+    InboundConfig,
+    KeepaliveConfig,
+    MarkdownConverter,
+    MediaCacheConfig,
+    MediaCapabilities,
+    NameCacheConfig,
+    OutboundConfig,
+    OversizeContext,
+    PerChatReplyMode,
+    PolicyConfig,
+    RetryConfig,
+    ResourceOverflowPolicy,
+    SafetyConfig,
+    SenderIdentityField,
+    SecurityConfig,
+    SecurityMode,
+    StreamThrottleConfig,
+    TextBatchConfig,
+    TransportConfig,
+    UATConfig,
+)
+from .events import ChannelEventName, Events
+from .errors import (
+    FeishuChannelError,
+    FeishuChannelErrorCode,
+    OutboundSendError,
+    SendError,
+    UATAuthError,
+    classify_api_error,
+    classify_error,
+    classify_http_status,
+    is_format_error,
+    is_reply_target_gone,
+    is_retryable,
+)
+from .identity import IdentityResolver, NameCache
+from .normalize import (
+    CommentEvent,
+    CommentOperator,
+    DedupStore,
+    InMemoryDedupStore,
+    InboundPipeline,
+    flatten as flatten_content,
+    make_event_key,
+    make_message_key,
+    normalize_comment,
+    parse_message_content,
+)
+from .outbound import OutboundSender, infer_receive_id_type, markdown_to_post_ast
+from .outbound.media.ssrf_guard import assert_public_url
+from .outbound.streaming import Throttle, UpdateQueue, merge_streaming_text
+from .outbound.streaming.card_stream import CardStreamController
+from .outbound.streaming.markdown_stream import MarkdownStreamController
+from .safety import (
+    ChatPipeline,
+    ChatPipelineManager,
+    MediaBatchConfig,
+    PolicyDecision,
+    PolicyGate,
+    ProcessingLock,
+    RejectEvent,
+    RejectReason,
+    SafetyPipeline,
+    SeenCache,
+    is_stale,
+    merge_batch,
+)
+from .types import (
+    AudioContent,
+    BotAddedEvent,
+    BotLeaveEvent,
+    CalendarContent,
+    CardActionEvent,
+    CardActionPayload,
+    CardPayload,
+    CachedResource,
+    ChatInfo,
+    CommentContext,
+    CommentTarget,
+    ConnectionSnapshot,
+    Conversation,
+    EventOperator,
+    FileContent,
+    FolderContent,
+    GeneralCalendarContent,
+    HongbaoContent,
+    RedPacketContent,
+    Identity,
+    ImageContent,
+    InboundMessage,
+    InteractiveContent,
+    LocationContent,
+    MediaContent,
+    MediaRef,
+    MediaSource,
+    Mention,
+    MergeForwardContent,
+    MergeForwardItem,
+    MessageContent,
+    MessageReadEvent,
+    OutboundAudio,
+    OutboundCard,
+    OutboundFile,
+    OutboundImage,
+    OutboundMessage,
+    OutboundPost,
+    OutboundText,
+    OutboundShareChat,
+    OutboundShareUser,
+    OutboundSticker,
+    OutboundVideo,
+    PostContent,
+    QuotedContext,
+    QuoteResolution,
+    ReactionEvent,
+    ReplyRef,
+    ResourceDescriptor,
+    ResourceType,
+    ReplyTargetGoneBehavior,
+    SendOpts,
+    SendResult,
+    ShareCalendarEventContent,
+    ShareChatContent,
+    ShareUserContent,
+    StickerContent,
+    SystemContent,
+    Target,
+    TextContent,
+    TodoContent,
+    UAT,
+    UnknownContent,
+    UserAccessToken,
+    VideoChatContent,
+    VoteContent,
+)
+
+__all__ = [
+    # Entry points
+    "FeishuChannel",
+    # Config
+    "ChannelConfig",
+    "ChatModeCacheConfig",
+    "ChatQueueConfig",
+    "DedupConfig",
+    "DmPolicy",
+    "FooterConfig",
+    "GroupOverride",
+    "GroupPolicy",
+    "InboundConfig",
+    "KeepaliveConfig",
+    "MarkdownConverter",
+    "MediaBatchConfig",
+    "MediaCacheConfig",
+    "MediaCapabilities",
+    "NameCacheConfig",
+    "OutboundConfig",
+    "OversizeContext",
+    "PerChatReplyMode",
+    "PolicyConfig",
+    "RetryConfig",
+    "ResourceOverflowPolicy",
+    "SafetyConfig",
+    "SenderIdentityField",
+    "SecurityConfig",
+    "SecurityMode",
+    "StreamThrottleConfig",
+    "TextBatchConfig",
+    "TransportConfig",
+    "UATConfig",
+    # Events
+    "ChannelEventName",
+    "Events",
+    # Card builder (Python ergonomics helper)
+    "CardBuilder",
+    "CardStreamController",
+    "MarkdownStreamController",
+    "Throttle",
+    "UpdateQueue",
+    "new_card",
+    "merge_streaming_text",
+    # Auth
+    "DeviceFlowClient",
+    "DeviceFlowInit",
+    "FileTokenStore",
+    "InMemoryTokenStore",
+    "TokenStore",
+    # Dedup
+    "DedupStore",
+    "InMemoryDedupStore",
+    "make_event_key",
+    "make_message_key",
+    # Identity
+    "IdentityResolver",
+    "NameCache",
+    # Pipeline helpers
+    "InboundPipeline",
+    "OutboundSender",
+    "infer_receive_id_type",
+    "markdown_to_post_ast",
+    "parse_message_content",
+    # Safety
+    "BotIdentity",
+    "ChatPipeline",
+    "ChatPipelineManager",
+    "PolicyDecision",
+    "PolicyGate",
+    "ProcessingLock",
+    "RejectEvent",
+    "RejectReason",
+    "SafetyPipeline",
+    "SeenCache",
+    "fetch_bot_identity",
+    "is_stale",
+    "merge_batch",
+    # Errors
+    "FeishuChannelError",
+    "FeishuChannelErrorCode",
+    "OutboundSendError",
+    "SendError",
+    "UATAuthError",
+    "assert_public_url",
+    "classify_api_error",
+    "classify_error",
+    "classify_http_status",
+    "is_format_error",
+    "is_reply_target_gone",
+    "is_retryable",
+    # Types
+    "AudioContent",
+    "BotAddedEvent",
+    "BotLeaveEvent",
+    "CalendarContent",
+    "CardActionEvent",
+    "CardActionPayload",
+    "CardPayload",
+    "CachedResource",
+    "ChatInfo",
+    "CommentContext",
+    "CommentTarget",
+    "CommentEvent",
+    "CommentOperator",
+    "ConnectionSnapshot",
+    "Conversation",
+    "EventOperator",
+    "FileContent",
+    "FolderContent",
+    "GeneralCalendarContent",
+    "HongbaoContent",
+    "RedPacketContent",
+    "Identity",
+    "ImageContent",
+    "InboundMessage",
+    "InteractiveContent",
+    "LocationContent",
+    "MediaContent",
+    "MediaRef",
+    "MediaSource",
+    "Mention",
+    "MergeForwardContent",
+    "MergeForwardItem",
+    "MessageContent",
+    "MessageReadEvent",
+    "OutboundAudio",
+    "OutboundCard",
+    "OutboundFile",
+    "OutboundImage",
+    "OutboundMessage",
+    "OutboundPost",
+    "OutboundText",
+    "OutboundShareChat",
+    "OutboundShareUser",
+    "OutboundSticker",
+    "OutboundVideo",
+    "PostContent",
+    "QuotedContext",
+    "QuoteResolution",
+    "ReactionEvent",
+    "ReplyRef",
+    "ResourceDescriptor",
+    "ResourceType",
+    "ReplyTargetGoneBehavior",
+    "SendOpts",
+    "SendResult",
+    "ShareCalendarEventContent",
+    "ShareChatContent",
+    "ShareUserContent",
+    "StickerContent",
+    "SystemContent",
+    "Target",
+    "TextContent",
+    "TodoContent",
+    "UAT",
+    "UnknownContent",
+    "UserAccessToken",
+    "VideoChatContent",
+    "VoteContent",
+    "flatten_content",
+    "normalize_comment",
+]
diff --git a/lark_channel/channel/_api_helpers.py b/lark_channel/channel/_api_helpers.py
new file mode 100644
index 0000000..c37d966
--- /dev/null
+++ b/lark_channel/channel/_api_helpers.py
@@ -0,0 +1,358 @@
+"""Helpers around raw Lark API calls used by :class:`FeishuChannel`.
+
+**Internal module — do not import from outside ``lark_channel.channel``.** The
+leading underscore in the module name is Python's convention for "package
+private". Names, signatures, and behaviour here are free to change between
+minor versions without deprecation warnings.
+
+Pure async functions taking the underlying ``lark_channel.Client``. Extracted
+from :mod:`.channel` to keep the main class focused on lifecycle and
+dispatch; boilerplate around ``contact.v3.user.batch`` / ``im.v1.chat.aget``
+lives here instead.
+"""
+
+import asyncio
+from typing import Any, Dict, List, Optional
+
+from lark_channel.core.log import logger
+
+from .types import ChatInfo, Identity
+
+
+async def default_name_lookup(
+    lark_client: Any, open_ids: List[str]
+) -> Dict[str, Identity]:
+    """Resolve open_ids to :class:`Identity` via ``contact.v3.user.batch``.
+
+    Returns ``{}`` on any error so callers degrade gracefully.
+    """
+    if not open_ids:
+        return {}
+    try:
+        from lark_channel.api.contact.v3.model.batch_user_request import (
+            BatchUserRequest,
+        )
+    except ImportError:  # pragma: no cover
+        return {}
+    try:
+        req_b = (
+            BatchUserRequest.builder()
+            .user_id_type("open_id")
+            .user_ids(list(open_ids))
+        )
+        resp = await lark_client.contact.v3.user.abatch(req_b.build())
+        data = getattr(resp, "data", None)
+        items = getattr(data, "items", None) or []
+        out: Dict[str, Identity] = {}
+        for item in items:
+            oid = getattr(item, "open_id", None)
+            if not oid:
+                continue
+            out[oid] = Identity(
+                open_id=oid,
+                union_id=getattr(item, "union_id", None),
+                user_id=getattr(item, "user_id", None),
+                display_name=getattr(item, "name", None)
+                or getattr(item, "en_name", None),
+            )
+        return out
+    except Exception as e:  # pragma: no cover
+        logger.debug("default_name_lookup failed: %s", e)
+        return {}
+
+
+async def fetch_chat_info(lark_client: Any, chat_id: str) -> Optional[ChatInfo]:
+    """Fetch chat metadata via ``im.v1.chat.aget``. Returns ``None`` on failure.
+
+    Public-API callers expect ``Optional[ChatInfo]``, so failures are logged
+    rather than raised. The log always includes ``chat_id`` so operators can
+    correlate "this lookup came back empty" with the actual upstream reason
+    (403 / 404 / token expired / network).
+    """
+    try:
+        from lark_channel.api.im.v1.model.get_chat_request import GetChatRequest
+
+        req = GetChatRequest.builder().chat_id(chat_id).build()
+        resp = await lark_client.im.v1.chat.aget(req)
+        code = getattr(resp, "code", None)
+        if code is not None and code != 0:
+            logger.warning(
+                "fetch_chat_info: chat_id=%s code=%s msg=%s",
+                chat_id, code, getattr(resp, "msg", ""),
+            )
+            return None
+        data = getattr(resp, "data", None)
+        if data is None:
+            return None
+        raw_dict: Dict[str, Any] = {}
+        for attr in ("name", "description", "chat_type", "chat_mode", "owner_id", "user_count"):
+            v = getattr(data, attr, None)
+            if v is not None:
+                raw_dict[attr] = v
+        member_count = None
+        uc = getattr(data, "user_count", None)
+        if uc is not None:
+            try:
+                member_count = int(uc)
+            except (TypeError, ValueError):
+                pass
+        return ChatInfo(
+            chat_id=chat_id,
+            name=getattr(data, "name", None),
+            description=getattr(data, "description", None),
+            chat_type=getattr(data, "chat_type", "unknown") or "unknown",
+            owner_id=getattr(data, "owner_id", None),
+            member_count=member_count,
+            raw=raw_dict,
+        )
+    except Exception as e:  # pragma: no cover
+        logger.warning(
+            "fetch_chat_info: chat_id=%s raised: %s", chat_id, e,
+        )
+        return None
+
+
+async def fetch_message_raw(
+    lark_client: Any,
+    message_id: str,
+    *,
+    card_content_type: Optional[str] = None,
+) -> Optional[Dict[str, Any]]:
+    try:
+        from lark_channel.api.im.v1.model.get_message_request import GetMessageRequest
+
+        req = GetMessageRequest.builder().message_id(message_id).build()
+        if card_content_type:
+            req.add_query("card_msg_content_type", card_content_type)
+        resp = await lark_client.im.v1.message.aget(req)
+        code = resp.get("code") if isinstance(resp, dict) else getattr(resp, "code", None)
+        if code is not None and code != 0:
+            return None
+        return _object_to_dict(resp)
+    except Exception:
+        return None
+
+
+async def fetch_history(
+    lark_client: Any,
+    *,
+    chat_id: str,
+    limit: Optional[int] = None,
+    before_id: Optional[str] = None,
+) -> List[Any]:
+    """Fetch recent messages for ``chat_id``.
+
+    ``before_id`` is accepted for source compatibility with earlier internal
+    call sites, but the generated list-message builder available here does not
+    expose cursoring by message id, so this helper currently ignores it.
+    """
+    _ = before_id
+    try:
+        from lark_channel.api.im.v1.model.list_message_request import ListMessageRequest
+
+        req_b = (
+            ListMessageRequest.builder()
+            .container_id_type("chat")
+            .container_id(chat_id)
+        )
+        if limit:
+            req_b = req_b.page_size(limit)
+        resp = await lark_client.im.v1.message.alist(req_b.build())
+        data = getattr(resp, "data", None)
+        return list(getattr(data, "items", None) or [])
+    except Exception as e:  # pragma: no cover
+        logger.warning("fetch_history failed: %s", e)
+        return []
+
+
+def _object_to_dict(value: Any) -> Any:
+    if value is None:
+        return None
+    if isinstance(value, dict):
+        return {key: _object_to_dict(val) for key, val in value.items()}
+    if isinstance(value, list):
+        return [_object_to_dict(item) for item in value]
+    if hasattr(value, "__dict__"):
+        return {
+            key: _object_to_dict(val)
+            for key, val in value.__dict__.items()
+            if not key.startswith("_")
+        }
+    return value
+
+
+async def download_media(
+    lark_client: Any,
+    *,
+    message_id: str,
+    file_key: str,
+    resource_type: str,
+) -> Optional[bytes]:
+    """Download a message resource (image / file / audio / video attachment).
+
+    Returns the raw bytes, or ``None`` on any failure. The ``None`` contract
+    is preserved for back-compat with the public
+    :meth:`FeishuChannel.download_resource`; failures are logged with the
+    ``message_id`` + ``file_key`` + ``resource_type`` triple so operators
+    can pin down which download dropped.
+    """
+    try:
+        # Route by whether the caller supplied a message_id:
+        # * With message_id — the key belongs to a message attachment, so the
+        #   correct endpoint is `GET /im/v1/messages/:message_id/resources/:file_key`.
+        # * Without message_id — the key was minted by a standalone upload
+        #   (`POST /im/v1/images` or `POST /im/v1/files`), which is served
+        #   by `GET /im/v1/images/:image_key` or `GET /im/v1/files/:file_key`.
+        # An empty ``message_id`` against the message-resource endpoint
+        # returns 200 with no body, so route to the standalone endpoints in
+        # that case.
+        if message_id:
+            from lark_channel.api.im.v1.model.get_message_resource_request import (
+                GetMessageResourceRequest,
+            )
+            req = (
+                GetMessageResourceRequest.builder()
+                .message_id(message_id)
+                .file_key(file_key)
+                .type(resource_type)
+                .build()
+            )
+            resp = await _get_off_thread(lark_client.im.v1.message_resource, req)
+        elif resource_type == "image":
+            from lark_channel.api.im.v1.model.get_image_request import GetImageRequest
+            req = GetImageRequest.builder().image_key(file_key).build()
+            resp = await _get_off_thread(lark_client.im.v1.image, req)
+        else:
+            from lark_channel.api.im.v1.model.get_file_request import GetFileRequest
+            req = GetFileRequest.builder().file_key(file_key).build()
+            resp = await _get_off_thread(lark_client.im.v1.file, req)
+
+        code = getattr(resp, "code", None)
+        if code is not None and code != 0:
+            logger.warning(
+                "download_media: message_id=%s file_key=%s type=%s "
+                "code=%s msg=%s",
+                message_id, file_key, resource_type,
+                code, getattr(resp, "msg", ""),
+            )
+            return None
+        f = getattr(resp, "file", None)
+        if hasattr(f, "read"):
+            return f.read()
+        if isinstance(f, (bytes, bytearray)):
+            return bytes(f)
+        logger.warning(
+            "download_media: message_id=%s file_key=%s type=%s — "
+            "response succeeded but has no file payload",
+            message_id, file_key, resource_type,
+        )
+        return None
+    except Exception as e:  # pragma: no cover
+        logger.warning(
+            "download_media: message_id=%s file_key=%s type=%s raised: %s",
+            message_id, file_key, resource_type, e,
+        )
+        return None
+
+
+async def download_media_with_meta(
+    lark_client: Any,
+    *,
+    message_id: str,
+    file_key: str,
+    resource_type: str,
+) -> "tuple[Optional[bytes], Optional[str]]":
+    """Like :func:`download_media` but also returns a content-type / extension hint.
+
+    The second element of the tuple is one of:
+
+    - the response's ``content_type`` field (preferred, when surfaced);
+    - the response's ``file_name`` (used to derive a suffix via mimetypes);
+    - ``None`` when nothing is available — the caller falls back to a
+      generic suffix.
+
+    Returns ``(None, None)`` on any failure, mirroring ``download_media``'s
+    None-on-failure shape.
+    """
+    try:
+        if message_id:
+            from lark_channel.api.im.v1.model.get_message_resource_request import (
+                GetMessageResourceRequest,
+            )
+            req = (
+                GetMessageResourceRequest.builder()
+                .message_id(message_id)
+                .file_key(file_key)
+                .type(resource_type)
+                .build()
+            )
+            resp = await _get_off_thread(lark_client.im.v1.message_resource, req)
+        elif resource_type == "image":
+            from lark_channel.api.im.v1.model.get_image_request import GetImageRequest
+            req = GetImageRequest.builder().image_key(file_key).build()
+            resp = await _get_off_thread(lark_client.im.v1.image, req)
+        else:
+            from lark_channel.api.im.v1.model.get_file_request import GetFileRequest
+            req = GetFileRequest.builder().file_key(file_key).build()
+            resp = await _get_off_thread(lark_client.im.v1.file, req)
+
+        code = getattr(resp, "code", None)
+        if code is not None and code != 0:
+            logger.warning(
+                "download_media_with_meta: message_id=%s file_key=%s type=%s "
+                "code=%s msg=%s",
+                message_id, file_key, resource_type,
+                code, getattr(resp, "msg", ""),
+            )
+            return None, None
+
+        f = getattr(resp, "file", None)
+        body: Optional[bytes]
+        if hasattr(f, "read"):
+            body = f.read()
+        elif isinstance(f, (bytes, bytearray)):
+            body = bytes(f)
+        else:
+            body = None
+
+        content_type: Optional[str] = (
+            getattr(resp, "content_type", None)
+            or getattr(resp, "mime_type", None)
+            or getattr(resp, "file_name", None)
+        )
+
+        return body, content_type
+    except Exception as e:  # pragma: no cover
+        logger.warning(
+            "download_media_with_meta: message_id=%s file_key=%s type=%s raised: %s",
+            message_id, file_key, resource_type, e,
+        )
+        return None, None
+
+
+async def mark_read(lark_client: Any, *, message_ids: List[str]) -> Dict[str, Any]:
+    try:
+        from lark_channel.api.im.v1.model.read_users_message_request import (
+            ReadUsersMessageRequest,
+        )
+        from lark_channel.api.im.v1.model.read_users_message_request_body import (
+            ReadUsersMessageRequestBody,
+        )
+
+        body = (
+            ReadUsersMessageRequestBody.builder()
+            .message_id_list(message_ids)
+            .build()
+        )
+        req = ReadUsersMessageRequest.builder().request_body(body).build()
+        resp = await lark_client.im.v1.message.aread_users(req)
+        return {
+            "code": getattr(resp, "code", 0),
+            "msg": getattr(resp, "msg", "") or "",
+        }
+    except Exception as e:  # pragma: no cover
+        return {"code": -1, "msg": str(e)}
+
+
+async def _get_off_thread(resource: Any, request: Any) -> Any:
+    return await asyncio.to_thread(resource.get, request)
diff --git a/lark_channel/channel/_coerce.py b/lark_channel/channel/_coerce.py
new file mode 100644
index 0000000..94757e5
--- /dev/null
+++ b/lark_channel/channel/_coerce.py
@@ -0,0 +1,252 @@
+"""Input coercion helpers shared by :class:`FeishuChannel`.
+
+**Internal module — do not import from outside ``lark_channel.channel``.** The
+leading underscore in the module name is Python's convention for "package
+private". Names, signatures, and behaviour here are free to change between
+minor versions without deprecation warnings. ``FeishuChannel.send`` /
+``.stream`` etc. are the public surface; use them instead of ``coerce_*``
+helpers directly.
+
+These turn node-style dict / string / dataclass inputs into the internal
+:class:`OutboundMessage` / :class:`MediaSource` / :class:`SendOpts` shapes the
+sender expects. Extracted from :mod:`.channel` to keep the main class focused.
+"""
+
+import inspect
+import json
+from typing import Any, Dict, Optional, Union
+
+from lark_channel.core.json import JSON
+
+from .errors import FeishuChannelErrorCode, SendError
+from .types import (
+    MediaSource,
+    OutboundAudio,
+    OutboundCard,
+    OutboundFile,
+    OutboundImage,
+    OutboundMessage,
+    OutboundPost,
+    OutboundShareChat,
+    OutboundShareUser,
+    OutboundSticker,
+    OutboundText,
+    OutboundVideo,
+    SendOpts,
+    SendResult,
+)
+
+
+# --------------------------------------------------------------------------
+# Event-name normalization (node-aligned)
+# --------------------------------------------------------------------------
+
+VALID_EVENTS = {
+    "message",
+    "interaction", "cardAction", "card_action",
+    "reaction",
+    "bot_added", "botAdded",
+    "bot_left", "botLeave", "bot_leave",
+    "message_read", "messageRead",
+    "reject",
+    "comment",
+    "raw", "raw_event",
+    "reconnecting",
+    "reconnected",
+    "error",
+}
+
+_EVENT_ALIASES = {
+    "card_action": "cardAction",
+    "interaction": "cardAction",
+    "bot_added": "botAdded",
+    "bot_join": "botAdded",
+    "bot_left": "botLeave",
+    "bot_leave": "botLeave",
+    "message_read": "messageRead",
+    "raw_event": "raw",
+}
+
+
+def normalize_event_name(name: str) -> str:
+    return _EVENT_ALIASES.get(name, name)
+
+
+# --------------------------------------------------------------------------
+# Input coercion
+# --------------------------------------------------------------------------
+
+
+def coerce_outbound(
+    input_: Union[Dict[str, Any], OutboundMessage, str],
+) -> OutboundMessage:
+    if isinstance(input_, str):
+        return OutboundPost(markdown=input_)
+    if isinstance(
+        input_,
+        (
+            OutboundText, OutboundPost, OutboundCard, OutboundImage,
+            OutboundFile, OutboundAudio, OutboundVideo,
+            OutboundShareChat, OutboundShareUser, OutboundSticker,
+        ),
+    ):
+        return input_
+    if not isinstance(input_, dict):
+        raise TypeError(f"Unsupported send input: {type(input_).__name__}")
+
+    if "markdown" in input_:
+        return OutboundPost(markdown=input_["markdown"])
+    if "text" in input_:
+        return OutboundText(text=input_["text"])
+    if "post" in input_:
+        return OutboundPost(post=input_["post"])
+    if "card" in input_:
+        return OutboundCard(card=input_["card"])
+    if "image" in input_:
+        return OutboundImage(
+            source=coerce_media_source(input_["image"], kind="image"),
+            caption=_coerce_caption(input_.get("caption")),
+        )
+    if "file" in input_:
+        return OutboundFile(
+            source=coerce_media_source(input_["file"], kind="file"),
+            file_name=_dict_get_any(input_["file"], ("fileName", "file_name")),
+            caption=_coerce_caption(input_.get("caption")),
+        )
+    if "audio" in input_:
+        return OutboundAudio(
+            source=coerce_media_source(input_["audio"], kind="audio"),
+            caption=_coerce_caption(input_.get("caption")),
+        )
+    if "video" in input_:
+        return OutboundVideo(
+            source=coerce_media_source(input_["video"], kind="video"),
+            caption=_coerce_caption(input_.get("caption")),
+        )
+    if "share_chat" in input_ or "shareChat" in input_:
+        spec = input_.get("share_chat") or input_.get("shareChat") or {}
+        chat_id = spec if isinstance(spec, str) else _dict_get_any(
+            spec, ("chat_id", "chatId")
+        )
+        if not chat_id:
+            raise TypeError("share_chat requires a chat_id (str or {chat_id: ...})")
+        return OutboundShareChat(chat_id=chat_id)
+    if "share_user" in input_ or "shareUser" in input_:
+        spec = input_.get("share_user") or input_.get("shareUser") or {}
+        user_id = spec if isinstance(spec, str) else _dict_get_any(
+            spec, ("user_id", "userId", "open_id", "openId")
+        )
+        if not user_id:
+            raise TypeError("share_user requires a user_id (str or {user_id: ...})")
+        return OutboundShareUser(user_id=user_id)
+    if "sticker" in input_:
+        spec = input_["sticker"]
+        file_key = spec if isinstance(spec, str) else _dict_get_any(
+            spec, ("file_key", "fileKey")
+        )
+        if not file_key:
+            raise TypeError("sticker requires a file_key (str or {file_key: ...})")
+        return OutboundSticker(file_key=file_key)
+    raise TypeError(f"send: unrecognized input keys {list(input_.keys())}")
+
+
+def coerce_media_source(spec: Any, *, kind: str) -> MediaSource:
+    if isinstance(spec, MediaSource):
+        return spec
+    if isinstance(spec, bytes):
+        return MediaSource(kind="buffer", buffer=spec)
+    if not isinstance(spec, dict):
+        raise TypeError(f"{kind} input must be a dict or MediaSource")
+    src = spec.get("source")
+    if isinstance(src, MediaSource):
+        return src
+    if isinstance(src, bytes):
+        return MediaSource(kind="buffer", buffer=src)
+    if isinstance(src, str):
+        if src.startswith(("http://", "https://")):
+            return MediaSource(kind="url", url=src)
+        if src.startswith(("img_", "file_", "st_")):
+            return MediaSource(kind="key", key=src)
+        return MediaSource(kind="file", path=src)
+    raise TypeError(f"{kind}.source must be str (url/path) or bytes")
+
+
+def coerce_send_opts(
+    opts: Optional[Union[SendOpts, Dict[str, Any]]],
+) -> SendOpts:
+    if opts is None:
+        return SendOpts()
+    if isinstance(opts, SendOpts):
+        _coerce_reply_target_gone(opts.reply_target_gone)
+        return opts
+    if not isinstance(opts, dict):
+        raise TypeError("send opts must be SendOpts or dict")
+    return SendOpts(
+        reply_to=_dict_get_any(opts, ("replyTo", "reply_to")),
+        reply_in_thread=_dict_get_any(opts, ("replyInThread", "reply_in_thread")),
+        receive_id=_dict_get_any(opts, ("receiveId", "receive_id")),
+        receive_id_type=_dict_get_any(opts, ("receiveIdType", "receive_id_type")),
+        uuid=opts.get("uuid"),
+        reply_target_gone=_coerce_reply_target_gone(
+            _dict_get_any(opts, ("replyTargetGone", "reply_target_gone"))
+        ),
+    )
+
+
+def _dict_get_any(d: Dict[str, Any], keys) -> Any:
+    for k in keys:
+        if k in d:
+            return d[k]
+    return None
+
+
+def _coerce_reply_target_gone(value: Any) -> str:
+    value = value or "fresh"
+    if value not in ("fresh", "fail"):
+        raise ValueError(f"invalid reply_target_gone: {value}")
+    return value
+
+
+def _coerce_caption(value: Any) -> Optional[str]:
+    if value is None or value == "":
+        return None
+    if not isinstance(value, str):
+        raise TypeError("caption must be a string")
+    return value
+
+
+def result_from_raw(raw: Any, *, message_id: Optional[str] = None) -> SendResult:
+    if not isinstance(raw, dict):
+        return SendResult.ok(message_id=message_id)
+    code = raw.get("code", 0)
+    if code == 0:
+        return SendResult.ok(message_id=message_id, raw=raw)
+    return SendResult.fail(
+        SendError(
+            code=FeishuChannelErrorCode.UNKNOWN,
+            retryable=False,
+            raw_code=int(code),
+            hint=raw.get("msg"),
+        ),
+        raw=raw,
+    )
+
+
+async def maybe_await(v: Any) -> Any:
+    if inspect.isawaitable(v):
+        return await v
+    return v
+
+
+def obj_to_dict(obj: Any) -> Dict[str, Any]:
+    """Marshal SDK event objects to plain dicts via the shared JSON encoder."""
+    if isinstance(obj, dict):
+        return obj
+    try:
+        s = JSON.marshal(obj)
+        if not s:
+            return {}
+        parsed = json.loads(s)
+        return parsed if isinstance(parsed, dict) else {}
+    except Exception:  # pragma: no cover
+        return {}
diff --git a/lark_channel/channel/auth/__init__.py b/lark_channel/channel/auth/__init__.py
new file mode 100644
index 0000000..58eeeb9
--- /dev/null
+++ b/lark_channel/channel/auth/__init__.py
@@ -0,0 +1,12 @@
+"""UAT auth: TokenStore + Device Flow helpers."""
+
+from .device_flow import DeviceFlowClient, DeviceFlowInit
+from .token_store import FileTokenStore, InMemoryTokenStore, TokenStore
+
+__all__ = [
+    "DeviceFlowClient",
+    "DeviceFlowInit",
+    "FileTokenStore",
+    "InMemoryTokenStore",
+    "TokenStore",
+]
diff --git a/lark_channel/channel/auth/device_flow.py b/lark_channel/channel/auth/device_flow.py
new file mode 100644
index 0000000..75e4c31
--- /dev/null
+++ b/lark_channel/channel/auth/device_flow.py
@@ -0,0 +1,208 @@
+"""Lark User Access Token Device Flow.
+
+Implements the three steps:
+    1. start: POST /open-apis/authen/v2/oauth/device_authorization → get
+       verification_uri + user_code + device_code + expires_in + interval
+    2. wait: the user clicks the URL in Lark, enters the user_code, grants
+       scopes
+    3. poll: POST /open-apis/authen/v2/oauth/token with grant_type=device_code
+       until we get access_token / refresh_token
+
+Refresh uses grant_type=refresh_token on the same /token endpoint.
+
+This client deliberately does NOT import the Lark HTTP transport — we go
+straight to `httpx` so it's easy to unit-test with `respx` / mock.
+"""
+
+import asyncio
+import re
+import time
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+
+import httpx
+
+from lark_channel.core.const import FEISHU_DOMAIN
+from lark_channel.core.log import logger
+
+from ..errors import UATAuthError
+from ..types import UAT
+
+
+_HTML_TAG_RE = re.compile(r"<[^>]*>")
+
+
+def _safe_body_snippet(text: str, limit: int = 200) -> str:
+    """Strip HTML tags and truncate, so an unexpected upstream response body
+    can't flow verbatim into a user-visible card prompt."""
+    if not text:
+        return ""
+    stripped = _HTML_TAG_RE.sub(" ", text)
+    collapsed = " ".join(stripped.split())
+    if len(collapsed) > limit:
+        return collapsed[:limit] + "…"
+    return collapsed
+
+
+@dataclass
+class DeviceFlowInit:
+    verification_uri: str
+    verification_uri_complete: str
+    user_code: str
+    device_code: str
+    expires_in: int
+    interval: int = 5
+
+
+class DeviceFlowClient:
+    def __init__(
+        self,
+        app_id: str,
+        app_secret: str,
+        *,
+        domain: str = FEISHU_DOMAIN,
+        timeout: float = 30.0,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> None:
+        self._app_id = app_id
+        self._app_secret = app_secret
+        self._domain = domain.rstrip("/")
+        self._timeout = timeout
+        self._http = http_client
+        # Whether we own the client (and therefore must close it in `close()`).
+        # This is locked at construction — if a user-supplied client later
+        # appears closed, we fall back to a new internally-owned client (so the
+        # SDK stays usable) but we never *downgrade* an internally-owned
+        # client's ownership or *claim* ownership of the user's original.
+        self._owns_http = http_client is None
+
+    async def _client(self) -> httpx.AsyncClient:
+        if self._http is None:
+            self._http = httpx.AsyncClient(timeout=self._timeout)
+            self._owns_http = True
+        elif getattr(self._http, "is_closed", False):
+            # User-supplied client closed out from under us, or our own client
+            # was closed by some other path. Either way we must fall back to a
+            # fresh internally-owned client; we do NOT touch the user's
+            # original object again and we claim ownership of the *new* one.
+            self._http = httpx.AsyncClient(timeout=self._timeout)
+            self._owns_http = True
+        return self._http
+
+    async def close(self) -> None:
+        if self._http is not None and self._owns_http:
+            try:
+                await self._http.aclose()
+            except Exception:  # pragma: no cover - defensive
+                pass
+            self._http = None
+
+    async def start(self, scopes: List[str]) -> DeviceFlowInit:
+        body = {
+            "client_id": self._app_id,
+            "scope": " ".join(scopes) if scopes else "",
+        }
+        data = await self._post("/open-apis/authen/v2/oauth/device_authorization", body)
+        if data.get("code") and data.get("code") != 0:
+            raise UATAuthError(f"device_authorization failed: {data.get('msg')}")
+        # Some deployments return top-level fields; others wrap in data.
+        payload = data.get("data") or data
+        return DeviceFlowInit(
+            verification_uri=payload.get("verification_uri") or "",
+            verification_uri_complete=payload.get("verification_uri_complete")
+            or payload.get("verification_uri") or "",
+            user_code=payload.get("user_code") or "",
+            device_code=payload.get("device_code") or "",
+            expires_in=int(payload.get("expires_in") or 600),
+            interval=int(payload.get("interval") or 5),
+        )
+
+    async def poll(
+        self,
+        device_code: str,
+        *,
+        interval: int = 5,
+        timeout_seconds: Optional[int] = None,
+    ) -> UAT:
+        """Poll until authorization completes, scopes are denied, or timeout."""
+        deadline = time.time() + (timeout_seconds or 600)
+        delay = max(1, interval)
+        while time.time() < deadline:
+            body = {
+                "client_id": self._app_id,
+                "client_secret": self._app_secret,
+                "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+                "device_code": device_code,
+            }
+            resp = await self._post("/open-apis/authen/v2/oauth/token", body)
+            code = resp.get("code")
+            if code == 0 or "access_token" in resp or "access_token" in (resp.get("data") or {}):
+                return self._to_uat(resp)
+            err = resp.get("error") or resp.get("msg") or ""
+            if err in ("authorization_pending", "slow_down"):
+                if err == "slow_down":
+                    delay += 2
+                await asyncio.sleep(delay)
+                continue
+            if err in ("access_denied", "expired_token"):
+                raise UATAuthError(f"device flow failed: {err}")
+            # Lark-specific non-zero code
+            if isinstance(code, int) and code != 0:
+                raise UATAuthError(f"device flow error code={code} msg={resp.get('msg')}")
+            await asyncio.sleep(delay)
+        raise UATAuthError("device flow timed out")
+
+    async def refresh(self, refresh_token: str) -> UAT:
+        body = {
+            "client_id": self._app_id,
+            "client_secret": self._app_secret,
+            "grant_type": "refresh_token",
+            "refresh_token": refresh_token,
+        }
+        resp = await self._post("/open-apis/authen/v2/oauth/token", body)
+        code = resp.get("code")
+        if isinstance(code, int) and code != 0 and "access_token" not in resp:
+            raise UATAuthError(f"refresh failed: {resp.get('msg')}")
+        return self._to_uat(resp)
+
+    def _to_uat(self, resp: Dict[str, Any]) -> UAT:
+        payload = resp.get("data") if isinstance(resp.get("data"), dict) else resp
+        now = time.time()
+        expires_in = int(payload.get("expires_in") or 0)
+        refresh_expires_in = int(payload.get("refresh_token_expires_in") or 0)
+        scope_str = payload.get("scope") or ""
+        return UAT(
+            access_token=payload.get("access_token") or "",
+            refresh_token=payload.get("refresh_token"),
+            expires_at=now + expires_in if expires_in else None,
+            refresh_expires_at=now + refresh_expires_in if refresh_expires_in else None,
+            scopes=scope_str.split() if scope_str else [],
+            raw=payload if isinstance(payload, dict) else {},
+        )
+
+    async def _post(self, path: str, body: Dict[str, Any]) -> Dict[str, Any]:
+        url = self._domain + path
+        client = await self._client()
+        r = await client.post(url, json=body)
+        content_type = r.headers.get("content-type") or ""
+        try:
+            data = r.json()
+            if isinstance(data, dict):
+                return data
+        except Exception:  # pragma: no cover
+            pass
+        # Non-JSON response (HTML error page, WAF block, etc.). Log the full
+        # body at WARNING for diagnosis but surface a *truncated + stripped*
+        # version upstream so it cannot flow verbatim into user-visible card
+        # prompts (`uat_runner` embeds resp["msg"] into a card).
+        logger.warning(
+            "device flow: unexpected response %s %s body=%r",
+            r.status_code, content_type, r.text[:1024],
+        )
+        return {"code": r.status_code, "msg": _safe_body_snippet(r.text)}
+
+
+def uat_needs_refresh(uat: UAT, *, slack_seconds: int = 300) -> bool:
+    if uat.expires_at is None:
+        return False
+    return uat.expires_at - time.time() <= slack_seconds
diff --git a/lark_channel/channel/auth/token_store.py b/lark_channel/channel/auth/token_store.py
new file mode 100644
index 0000000..1ca2754
--- /dev/null
+++ b/lark_channel/channel/auth/token_store.py
@@ -0,0 +1,165 @@
+"""TokenStore interface + two built-in implementations.
+
+- `InMemoryTokenStore`: dict-based, process-local, ephemeral. Default.
+- `FileTokenStore`: plaintext JSON file. *Dev only* — constructor warns
+  loudly.
+
+Production users should implement their own TokenStore backed by Vault /
+KMS / managed database; see the `TokenStore` protocol below.
+"""
+
+import asyncio
+import json
+import os
+import threading
+import warnings
+from typing import Dict, Optional, Protocol, runtime_checkable
+
+from lark_channel.core.log import logger
+
+from ..types import UAT
+
+
+@runtime_checkable
+class TokenStore(Protocol):
+    """Async interface for UAT storage."""
+
+    async def get(self, user_id: str) -> Optional[UAT]: ...
+    async def set(self, user_id: str, token: UAT) -> None: ...
+    async def delete(self, user_id: str) -> None: ...
+
+
+class InMemoryTokenStore:
+    """Thread-safe dict-backed TokenStore. Loses state when the process dies."""
+
+    def __init__(self) -> None:
+        self._data: Dict[str, UAT] = {}
+        self._lock = threading.Lock()
+
+    async def get(self, user_id: str) -> Optional[UAT]:
+        with self._lock:
+            return self._data.get(user_id)
+
+    async def set(self, user_id: str, token: UAT) -> None:
+        with self._lock:
+            self._data[user_id] = token
+
+    async def delete(self, user_id: str) -> None:
+        with self._lock:
+            self._data.pop(user_id, None)
+
+    def clear(self) -> None:
+        with self._lock:
+            self._data.clear()
+
+
+class FileTokenStore:
+    """Plaintext JSON file TokenStore — development only.
+
+    Persists UATs across process restarts so you don't have to re-authorize on
+    every run. Emits a prominent warning so anybody reading the logs in a
+    production environment realizes this is not for them.
+    """
+
+    def __init__(self, path: str) -> None:
+        warnings.warn(
+            "FileTokenStore is not for production. Use a custom TokenStore "
+            "backed by Vault / KMS / encrypted database.",
+            UserWarning,
+            stacklevel=2,
+        )
+        logger.warning(
+            "FileTokenStore: storing UATs in plaintext at %s — dev only",
+            path,
+        )
+        self._path = path
+        # Defer lock creation to first use so the lock binds to the event loop
+        # that actually performs async I/O, not the loop that happened to be
+        # running at construction time (which may be a different loop when the
+        # store is shared with FeishuChannel's bg loop).
+        self._lock: Optional[asyncio.Lock] = None
+        self._mem: Dict[str, UAT] = self._load()
+
+    def _load(self) -> Dict[str, UAT]:
+        if not os.path.exists(self._path):
+            return {}
+        try:
+            with open(self._path, "r", encoding="utf-8") as fh:
+                raw = json.load(fh)
+            out: Dict[str, UAT] = {}
+            for k, v in (raw or {}).items():
+                if isinstance(v, dict):
+                    out[k] = UAT(
+                        access_token=v.get("access_token") or "",
+                        refresh_token=v.get("refresh_token"),
+                        expires_at=v.get("expires_at"),
+                        refresh_expires_at=v.get("refresh_expires_at"),
+                        scopes=list(v.get("scopes") or []),
+                        open_id=v.get("open_id"),
+                        raw=v.get("raw") or {},
+                    )
+            return out
+        except (OSError, ValueError) as e:
+            logger.warning("FileTokenStore: failed to load %s: %s", self._path, e)
+            return {}
+
+    def _persist(self) -> None:
+        serializable = {
+            k: {
+                "access_token": v.access_token,
+                "refresh_token": v.refresh_token,
+                "expires_at": v.expires_at,
+                "refresh_expires_at": v.refresh_expires_at,
+                "scopes": v.scopes,
+                "open_id": v.open_id,
+                "raw": v.raw,
+            }
+            for k, v in self._mem.items()
+        }
+        tmp = self._path + ".tmp"
+        # Open with explicit 0o600 permissions so the file is never
+        # world-readable on Linux, regardless of the caller's umask. Tokens
+        # are sensitive credentials.
+        flags = os.O_WRONLY | os.O_CREAT | os.O_TRUNC
+        fd = os.open(tmp, flags, 0o600)
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8") as fh:
+                json.dump(serializable, fh, ensure_ascii=False, indent=2)
+        except Exception:
+            # Best-effort cleanup of tmp on failure.
+            try:
+                os.unlink(tmp)
+            except OSError:
+                pass
+            raise
+        os.replace(tmp, self._path)
+        # Re-assert permissions on the final file in case `os.replace` didn't
+        # preserve them (some filesystems / prior-existing file with looser
+        # perms).
+        try:
+            os.chmod(self._path, 0o600)
+        except OSError as e:
+            logger.warning(
+                "FileTokenStore: failed to chmod 0600 on %s: %s", self._path, e
+            )
+
+    def _get_lock(self) -> asyncio.Lock:
+        if self._lock is None:
+            self._lock = asyncio.Lock()
+        return self._lock
+
+    async def get(self, user_id: str) -> Optional[UAT]:
+        async with self._get_lock():
+            return self._mem.get(user_id)
+
+    async def set(self, user_id: str, token: UAT) -> None:
+        async with self._get_lock():
+            self._mem[user_id] = token
+            # Offload the synchronous JSON write + os.replace to a worker
+            # thread so the event loop stays responsive.
+            await asyncio.get_running_loop().run_in_executor(None, self._persist)
+
+    async def delete(self, user_id: str) -> None:
+        async with self._get_lock():
+            self._mem.pop(user_id, None)
+            await asyncio.get_running_loop().run_in_executor(None, self._persist)
diff --git a/lark_channel/channel/auth/uat_runner.py b/lark_channel/channel/auth/uat_runner.py
new file mode 100644
index 0000000..7a1eeca
--- /dev/null
+++ b/lark_channel/channel/auth/uat_runner.py
@@ -0,0 +1,114 @@
+"""UAT device-flow runner — extracted from :class:`FeishuChannel`.
+
+Performs the "check cache → refresh if needed → start device flow → prompt
+user → poll until authorized" dance. Separated so :mod:`..channel` can stay
+focused on lifecycle.
+"""
+
+import asyncio
+from typing import Any, Dict, List
+
+from lark_channel.core.log import logger
+
+from ..card.builder import new_card as _card_factory
+from ..errors import UATAuthError
+from ..types import UAT
+from .device_flow import DeviceFlowClient, uat_needs_refresh
+from .token_store import TokenStore
+
+
+# Per-user-open-id asyncio locks so concurrent handler invocations for the
+# same user don't both try to refresh an expiring token simultaneously. The
+# interactive device-flow prompt/poll step runs outside this lock so a waiting
+# authorization does not block unrelated cache reads forever.
+# The locks bind to the loop of the first caller; callers on other loops fall
+# back to lock-less behaviour (rare; same-user concurrency across loops is not
+# a supported configuration).
+_user_locks: Dict[str, asyncio.Lock] = {}
+
+
+def _get_user_lock(user_open_id: str) -> asyncio.Lock:
+    """Lazily create + memoize a per-user asyncio.Lock on the current loop."""
+    return _user_locks.setdefault(user_open_id, asyncio.Lock())
+
+
+async def require_user_auth(
+    *,
+    device_flow: DeviceFlowClient,
+    token_store: TokenStore,
+    uat_config: Any,
+    user_open_id: str,
+    scopes: List[str],
+    context: Any,
+) -> UAT:
+    """Resolve a usable UAT for ``user_open_id``, running device flow if needed.
+
+    ``uat_config`` is a :class:`~..config.UATConfig` with scope allow/block
+    lists and the refresh slack; ``context`` is the object used to prompt the
+    user and should expose ``respond(card)``.
+
+    A per-user asyncio.Lock serializes concurrent callers for the same user
+    through cache lookup and refresh. The prompt/poll device-flow phase is
+    intentionally outside that lock.
+    """
+    ub = uat_config
+    if ub.allowed_scopes is not None:
+        for s in scopes:
+            if s not in ub.allowed_scopes:
+                raise UATAuthError(f"scope {s} not in allowed_scopes")
+    if ub.blocked_scopes:
+        for s in scopes:
+            if s in ub.blocked_scopes:
+                raise UATAuthError(f"scope {s} is blocked")
+
+    async with _get_user_lock(user_open_id or ""):
+        existing = await token_store.get(user_open_id or "")
+        if existing is not None:
+            missing = [s for s in scopes if s and s not in (existing.scopes or [])]
+            if not missing:
+                if uat_needs_refresh(
+                    existing, slack_seconds=ub.refresh_before_expiry_seconds
+                ):
+                    if existing.refresh_token:
+                        try:
+                            refreshed = await device_flow.refresh(existing.refresh_token)
+                            refreshed.open_id = user_open_id
+                            if not refreshed.scopes and existing.scopes:
+                                refreshed.scopes = existing.scopes
+                            await token_store.set(user_open_id, refreshed)
+                            return refreshed
+                        except UATAuthError:
+                            await token_store.delete(user_open_id)
+                    else:
+                        await token_store.delete(user_open_id)
+                else:
+                    return existing
+
+        init = await device_flow.start(scopes)
+    try:
+        prompt_card = (
+            _card_factory()
+            .header(title="Authorization required", template="blue")
+            .markdown(
+                f"Please click the link to complete authorization: "
+                f"{init.verification_uri_complete}\n\n"
+                f"User code: `{init.user_code}`\n"
+                f"Expires in: {init.expires_in}s"
+            )
+            .build()
+        )
+        if context is not None and hasattr(context, "respond"):
+            await context.respond(prompt_card)
+    except Exception as e:
+        logger.warning("require_user_auth: failed to send prompt card: %s", e)
+
+    uat = await device_flow.poll(
+        init.device_code,
+        interval=init.interval or ub.device_poll_interval_seconds,
+        timeout_seconds=init.expires_in,
+    )
+    uat.open_id = user_open_id
+    if not uat.scopes:
+        uat.scopes = list(scopes)
+    await token_store.set(user_open_id, uat)
+    return uat
diff --git a/lark_channel/channel/bot_identity.py b/lark_channel/channel/bot_identity.py
new file mode 100644
index 0000000..886dd87
--- /dev/null
+++ b/lark_channel/channel/bot_identity.py
@@ -0,0 +1,141 @@
+"""Bot identity auto-fetch.
+
+Resolution flow:
+    1. Try `GET /open-apis/bot/v3/info` (returns app_id / activate_status / name / open_id).
+    2. Fall back to `GET /open-apis/application/v6/applications/:app_id` (richer data).
+    3. Return `BotIdentity(open_id, user_id?, name?)`; the caller persists it on
+       the channel so group `@Bot` detection works correctly.
+
+The SDK does not ship a `bot.v3` generated resource, so we go through the raw
+Transport / BaseRequest primitives with a tenant token.
+"""
+
+import json
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+from lark_channel.core.const import UTF_8
+from lark_channel.core.enum import AccessTokenType, HttpMethod
+from lark_channel.core.http import Transport
+from lark_channel.core.log import logger
+from lark_channel.core.model import BaseRequest, Config, RawResponse, RequestOption
+from lark_channel.core.token.auth import verify as _verify_auth
+
+
+@dataclass
+class BotIdentity:
+    """Resolved bot identity: ``open_id`` plus optional ``user_id`` / ``name``.
+
+    ``name`` defaults to empty string because the ``/bot/v3/info`` fallback
+    path may not surface it in some tenant configurations — at which point
+    we'd rather degrade than crash. ``app_id`` is included for convenience
+    when callers need to correlate identities with their app registration.
+    """
+
+    open_id: str
+    user_id: Optional[str] = None
+    name: str = ""
+    app_id: Optional[str] = None
+
+
+def _raw_request(uri: str, method: HttpMethod = HttpMethod.GET) -> BaseRequest:
+    req = BaseRequest()
+    req.http_method = method
+    req.uri = uri
+    req.token_types = {AccessTokenType.TENANT}
+    return req
+
+
+async def fetch_bot_identity(config: Config) -> Optional[BotIdentity]:
+    """Return the bot's identity tuple, or None on failure.
+
+    Preferred path: /bot/v3/info — cheap and always available when the bot
+    capability is enabled. Falls back to application info.
+    """
+    primary = await _try_bot_v3_info(config)
+    if primary is not None:
+        return primary
+    return await _try_application_get(config)
+
+
+async def _try_bot_v3_info(config: Config) -> Optional[BotIdentity]:
+    try:
+        req = _raw_request("/open-apis/bot/v3/info")
+        option = RequestOption()
+        # Raw `Transport.aexecute` bypasses the Chain that normally injects
+        # the tenant token via `core.token.auth.verify`. Call it explicitly
+        # so `option.tenant_access_token` is populated before the request
+        # goes out (otherwise the header becomes literal `Bearer None` and
+        # Feishu rejects with 400).
+        _verify_auth(config, req, option)
+        resp = await Transport.aexecute(config, req, option)
+        data = _parse_data(resp)
+        if not data:
+            return None
+        bot = data.get("bot") or data
+        open_id = bot.get("open_id") or bot.get("openid") or ""
+        if not open_id:
+            return None
+        return BotIdentity(
+            open_id=open_id,
+            user_id=bot.get("user_id"),
+            name=bot.get("app_name") or bot.get("name"),
+            app_id=bot.get("app_id") or config.app_id,
+        )
+    except Exception as e:
+        logger.debug("fetch_bot_identity: /bot/v3/info failed: %s", e)
+        return None
+
+
+async def _try_application_get(config: Config) -> Optional[BotIdentity]:
+    if not config.app_id:
+        return None
+    try:
+        uri = f"/open-apis/application/v6/applications/{config.app_id}?lang=zh_cn"
+        req = _raw_request(uri)
+        option = RequestOption()
+        _verify_auth(config, req, option)  # inject tenant token; see _try_bot_v3_info
+        resp = await Transport.aexecute(config, req, option)
+        data = _parse_data(resp)
+        if not data:
+            return None
+        app = data.get("app") or data.get("application") or data
+        # application.v6 doesn't directly return open_id; some tenants expose
+        # `bot_info.open_id` though. Best-effort extraction.
+        open_id = ""
+        bot_info = app.get("bot_info") or app.get("bot") or {}
+        if isinstance(bot_info, dict):
+            open_id = bot_info.get("open_id") or bot_info.get("openid") or ""
+        if not open_id:
+            return None
+        return BotIdentity(
+            open_id=open_id,
+            name=app.get("app_name") or app.get("name"),
+            app_id=config.app_id,
+        )
+    except Exception as e:
+        logger.debug("fetch_bot_identity: /applications fallback failed: %s", e)
+        return None
+
+
+def _parse_data(resp: RawResponse) -> Optional[Dict[str, Any]]:
+    if resp is None or resp.content is None:
+        return None
+    try:
+        body = json.loads(resp.content.decode(UTF_8))
+    except (ValueError, UnicodeDecodeError):
+        return None
+    if not isinstance(body, dict):
+        return None
+    if body.get("code") and body.get("code") != 0:
+        logger.debug("fetch_bot_identity: api returned code=%s msg=%s", body.get("code"), body.get("msg"))
+        return None
+    # Most Feishu OpenAPI endpoints wrap payload in a `data` envelope, but
+    # `/bot/v3/info` puts `bot` directly at the top level (alongside the
+    # `code` / `msg` envelope keys). Support both shapes:
+    #   {"data": {"bot": {...}}, "code": 0}  → return data
+    #   {"bot": {...}, "code": 0, "msg": ""} → return body minus envelope
+    data = body.get("data")
+    if isinstance(data, dict):
+        return data
+    return {k: v for k, v in body.items() if k not in ("code", "msg")}
diff --git a/lark_channel/channel/card/__init__.py b/lark_channel/channel/card/__init__.py
new file mode 100644
index 0000000..a55d6ce
--- /dev/null
+++ b/lark_channel/channel/card/__init__.py
@@ -0,0 +1,9 @@
+"""CardKit v2 card builder (Python ergonomics helper).
+
+No streaming controller here — streaming is handled by
+:mod:`lark_channel.channel.outbound.streaming` (node-aligned ``update()`` API).
+"""
+
+from .builder import CardBuilder, new_card
+
+__all__ = ["CardBuilder", "new_card"]
diff --git a/lark_channel/channel/card/builder.py b/lark_channel/channel/card/builder.py
new file mode 100644
index 0000000..106e95c
--- /dev/null
+++ b/lark_channel/channel/card/builder.py
@@ -0,0 +1,337 @@
+"""CardKit v2 builder — fluent chain to compose interactive cards.
+
+Common elements are typed; `.raw()` provides an escape hatch for JSON not
+covered by the builder methods.
+"""
+
+import re
+from copy import deepcopy
+from typing import Any, Dict, List, Optional
+
+from ..types import CardPayload
+
+
+# Cell values containing these constructs should be rendered via `lark_md`
+# so bold/italic/code/link stay formatted; plain cells use `text`.
+_INLINE_MD_IN_CELL_RE = re.compile(
+    r"(\*\*[^*]+\*\*)|(\*[^*\s][^*]*\*)|(`[^`\n]+`)|(\[[^\]]+\]\([^)]+\))"
+)
+
+
+HeaderTemplate = str  # 'blue' | 'red' | 'green' | ...
+
+
+class CardBuilder:
+    """Fluent v2 card builder.
+
+    Example:
+        >>> c = (new_card()
+        ...     .header(title="Deploy", template="blue")
+        ...     .markdown("Running **step 2**")
+        ...     .divider()
+        ...     .button(label="Approve", action={"type": "approve"}, style="primary")
+        ...     .build())
+    """
+
+    def __init__(self) -> None:
+        self._header: Optional[Dict[str, Any]] = None
+        self._body_elements: List[Dict[str, Any]] = []
+        self._config: Dict[str, Any] = {}
+        self._variables: Dict[str, Any] = {}
+        self._streaming: bool = False
+
+    # ---- meta -----------------------------------------------------------------
+    def streaming(self, enabled: bool = True) -> "CardBuilder":
+        """Mark this card for use with the streaming card helpers."""
+        self._streaming = enabled
+        return self
+
+    def config(self, **kwargs: Any) -> "CardBuilder":
+        self._config.update(kwargs)
+        return self
+
+    def variable(self, name: str, value: Any) -> "CardBuilder":
+        self._variables[name] = value
+        return self
+
+    # ---- header ---------------------------------------------------------------
+    def header(
+        self,
+        title: str,
+        *,
+        subtitle: Optional[str] = None,
+        template: HeaderTemplate = "blue",
+        icon: Optional[Dict[str, Any]] = None,
+    ) -> "CardBuilder":
+        h: Dict[str, Any] = {"title": {"tag": "plain_text", "content": title}}
+        if subtitle:
+            h["subtitle"] = {"tag": "plain_text", "content": subtitle}
+        if template:
+            h["template"] = template
+        if icon:
+            h["icon"] = icon
+        self._header = h
+        return self
+
+    # ---- body element helpers ------------------------------------------------
+    def markdown(self, content: str) -> "CardBuilder":
+        self._body_elements.append({"tag": "markdown", "content": content})
+        return self
+
+    def text(self, content: str) -> "CardBuilder":
+        self._body_elements.append(
+            {"tag": "div", "text": {"tag": "plain_text", "content": content}}
+        )
+        return self
+
+    def divider(self) -> "CardBuilder":
+        self._body_elements.append({"tag": "hr"})
+        return self
+
+    def image(self, img_key: str, *, alt: Optional[str] = None, title: Optional[str] = None) -> "CardBuilder":
+        el: Dict[str, Any] = {"tag": "img", "img_key": img_key}
+        if alt:
+            el["alt"] = {"tag": "plain_text", "content": alt}
+        if title:
+            el["title"] = {"tag": "plain_text", "content": title}
+        self._body_elements.append(el)
+        return self
+
+    def note(self, elements: List[Dict[str, Any]]) -> "CardBuilder":
+        """Emit a subtle-styled line.
+
+        The v1 `note` tag is gone in CardKit v2; we flatten plain_text children
+        into a single grey markdown line so existing builder chains keep working.
+        """
+        if isinstance(elements, list):
+            parts = []
+            for el in elements:
+                if isinstance(el, dict) and el.get("tag") == "plain_text":
+                    parts.append(el.get("content", ""))
+                elif isinstance(el, dict):
+                    parts.append(el.get("content", "") or el.get("text", ""))
+                else:
+                    parts.append(str(el))
+            text = " · ".join(p for p in parts if p)
+        else:
+            text = str(elements)
+        self._body_elements.append(
+            {"tag": "markdown", "content": f"<font color='grey'>{text}</font>"}
+        )
+        return self
+
+    def code_block(self, content: str, language: str = "text") -> "CardBuilder":
+        self._body_elements.append(
+            {
+                "tag": "markdown",
+                "content": f"```{language}\n{content}\n```",
+            }
+        )
+        return self
+
+    # ---- interactive elements -----------------------------------------------
+    # CardKit v2 note: the `action` container tag from v1 is gone. Interactive
+    # widgets (button / select_static / etc.) are emitted as top-level body
+    # elements; multiple buttons on one row use `column_set`.
+
+    def _build_button(
+        self,
+        *,
+        label: str,
+        action: Optional[Dict[str, Any]] = None,
+        style: str = "default",
+        url: Optional[str] = None,
+        confirm: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        btn: Dict[str, Any] = {
+            "tag": "button",
+            "text": {"tag": "plain_text", "content": label},
+            "type": style,
+        }
+        if url:
+            btn["url"] = url
+        if action is not None:
+            btn["value"] = action
+        if confirm:
+            btn["confirm"] = confirm
+        return btn
+
+    def button(
+        self,
+        label: str,
+        *,
+        action: Optional[Dict[str, Any]] = None,
+        style: str = "default",
+        url: Optional[str] = None,
+        confirm: Optional[Dict[str, Any]] = None,
+    ) -> "CardBuilder":
+        self._body_elements.append(
+            self._build_button(label=label, action=action, style=style, url=url, confirm=confirm)
+        )
+        return self
+
+    def buttons(self, items: List[Dict[str, Any]]) -> "CardBuilder":
+        """Render several buttons in one horizontal row via column_set.
+
+        Each item uses `button`-style keys: label, action, style, url, confirm.
+        """
+        cols: List[Dict[str, Any]] = []
+        for it in items:
+            btn = self._build_button(
+                label=it.get("label", ""),
+                action=it.get("action"),
+                style=it.get("style", "default"),
+                url=it.get("url"),
+                confirm=it.get("confirm"),
+            )
+            cols.append({"tag": "column", "elements": [btn]})
+        self._body_elements.append({"tag": "column_set", "columns": cols})
+        return self
+
+    def select(
+        self,
+        placeholder: str,
+        *,
+        options: List[Dict[str, str]],
+        action: Optional[Dict[str, Any]] = None,
+    ) -> "CardBuilder":
+        sel: Dict[str, Any] = {
+            "tag": "select_static",
+            "placeholder": {"tag": "plain_text", "content": placeholder},
+            "options": [
+                {
+                    "text": {"tag": "plain_text", "content": o.get("label", "")},
+                    "value": o.get("value", ""),
+                }
+                for o in options
+            ],
+        }
+        if action is not None:
+            sel["value"] = action
+        self._body_elements.append(sel)
+        return self
+
+    def column_set(self, columns: List["CardBuilder"]) -> "CardBuilder":
+        """Emit a column_set whose sub-columns are themselves built via CardBuilder.
+
+        Only the body elements of each sub-builder are embedded (header and
+        streaming flags on sub-columns are ignored).
+        """
+        cols = [{"tag": "column", "elements": c._body_elements} for c in columns]
+        self._body_elements.append({"tag": "column_set", "columns": cols})
+        return self
+
+    def table(
+        self,
+        headers: List[str],
+        rows: List[List[str]],
+        *,
+        page_size: int = 5,
+        data_types: Optional[List[str]] = None,
+    ) -> "CardBuilder":
+        """Append a native Card 2.0 ``table`` component.
+
+        Emits the structured ``{"tag": "table", "columns": [...], "rows": [...]}``
+        element — **not** a GFM pipe-table stuffed into a markdown element.
+        Feishu's ``markdown`` and post ``md`` tags silently drop pipe-table
+        syntax, so the old string-based rendering showed as raw pipes or
+        blank messages. Use ``.raw({...})`` only if you need fields beyond
+        what this signature covers.
+
+        ``data_types`` overrides the per-column auto-detection. When omitted,
+        columns whose cells contain inline markdown (bold / italic / inline
+        code / link) pick ``lark_md``; plain columns pick ``text``.
+        ``page_size`` is clamped to Feishu's 1-10 range.
+        """
+        normalized_rows: List[List[str]] = []
+        for row in rows:
+            cells = [str(c) if c is not None else "" for c in row]
+            while len(cells) < len(headers):
+                cells.append("")
+            normalized_rows.append(cells[: len(headers)])
+
+        if data_types is not None and len(data_types) != len(headers):
+            raise ValueError(
+                "data_types length must match headers length"
+            )
+
+        columns: List[Dict[str, Any]] = []
+        for idx, header in enumerate(headers):
+            if data_types is not None:
+                data_type = data_types[idx]
+            else:
+                column_cells = (row[idx] for row in normalized_rows)
+                data_type = (
+                    "lark_md"
+                    if any(_INLINE_MD_IN_CELL_RE.search(c) for c in column_cells)
+                    else "text"
+                )
+            columns.append({
+                "name": f"col_{idx}",
+                "display_name": header,
+                "data_type": data_type,
+            })
+
+        rows_data = [
+            {f"col_{idx}": cell for idx, cell in enumerate(row)}
+            for row in normalized_rows
+        ]
+
+        self._body_elements.append({
+            "tag": "table",
+            "page_size": max(1, min(10, page_size)),
+            "columns": columns,
+            "rows": rows_data,
+        })
+        return self
+
+    def progress(self, percent: int, *, label: Optional[str] = None) -> "CardBuilder":
+        percent = max(0, min(100, percent))
+        bar = "▓" * (percent // 5) + "░" * (20 - percent // 5)
+        md = f"`{bar}`  **{percent}%**"
+        if label:
+            md = f"{label}\n{md}"
+        return self.markdown(md)
+
+    def footer(self, text: str) -> "CardBuilder":
+        self._body_elements.append(
+            {"tag": "markdown", "content": f"<font color='grey'>{text}</font>"}
+        )
+        return self
+
+    # ---- escape hatch --------------------------------------------------------
+    def raw(self, element: Dict[str, Any]) -> "CardBuilder":
+        self._body_elements.append(element)
+        return self
+
+    # ---- build ---------------------------------------------------------------
+    def to_dict(self) -> Dict[str, Any]:
+        card_dict: Dict[str, Any] = {
+            "schema": "2.0",
+            "config": dict(self._config),
+            "body": {"elements": list(self._body_elements)},
+        }
+        if self._streaming:
+            card_dict["config"]["streaming_mode"] = True
+            card_dict["config"]["summary"] = {"content": ""}
+        if self._header is not None:
+            card_dict["header"] = deepcopy(self._header)
+        if self._variables:
+            card_dict["variables"] = dict(self._variables)
+        return card_dict
+
+    def build(self) -> CardPayload:
+        return CardPayload(data=self.to_dict(), version="v2")
+
+
+def new_card() -> CardBuilder:
+    """Factory helper: return a fresh :class:`CardBuilder`.
+
+    Prefer ``new_card()`` over instantiating ``CardBuilder()`` directly — the
+    name documents intent and matches TypeScript's ``lark.newCard()``.
+    """
+    return CardBuilder()
+
+
+# Back-compat alias; scheduled for removal after 2.0.
+card = new_card
diff --git a/lark_channel/channel/channel.py b/lark_channel/channel/channel.py
new file mode 100644
index 0000000..61011e6
--- /dev/null
+++ b/lark_channel/channel/channel.py
@@ -0,0 +1,2567 @@
+"""lark_channel.channel.channel — the FeishuChannel capability layer.
+
+A single class owning lifecycle, transport (WS / webhook), inbound
+normalization, safety pipeline, outbound sender, and streaming.
+
+The event-registration API uses string events::
+
+    channel.on("message", handler)      # handler(inbound: InboundMessage)
+    channel.on("cardAction", handler)   # handler(event: CardActionEvent)
+    channel.on("reaction", handler)     # handler(event: ReactionEvent)
+    channel.on("botAdded", handler)     # handler(event: BotAddedEvent)
+    channel.on("botLeave", handler)
+    channel.on("messageRead", handler)
+    channel.on("comment", handler)
+    channel.on("reject", handler)       # handler(event: RejectEvent)
+    channel.on("reconnecting", handler)
+    channel.on("reconnected", handler)
+    channel.on("error", handler)
+
+For sending, streaming, message ops — use the channel methods directly
+(``channel.send(...)``, ``channel.stream(...)``, ``channel.update_card(...)``,
+etc). There are no typed-context hooks on event payloads — work with the
+plain event data and call back into the channel.
+
+Orchestration-only. Orthogonal concerns live next door:
+
+- Input coercion      → :mod:`._coerce`
+- Raw Lark API calls  → :mod:`._api_helpers`
+- UAT device flow     → :mod:`.auth.uat_runner`
+"""
+
+from __future__ import annotations
+
+import asyncio
+import concurrent.futures
+import inspect
+import json
+import threading
+import time
+from collections import OrderedDict
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Literal, Mapping, Optional, Set, Union
+
+from lark_channel.client import Client
+from lark_channel.core.enum import LogLevel
+from lark_channel.core.log import logger
+from lark_channel.event.callback.model.p2_card_action_trigger import (
+    P2CardActionTrigger,
+    P2CardActionTriggerResponse,
+)
+from lark_channel.event.dispatcher_handler import EventDispatcherHandler
+from lark_channel.ws.client import Client as WSClient
+
+from . import _api_helpers, _coerce
+from .auth.device_flow import DeviceFlowClient
+from .events import ChannelEventName
+from lark_channel.core.cache import ICache
+
+from .auth.token_store import InMemoryTokenStore, TokenStore
+from .auth.uat_runner import require_user_auth
+from .bot_identity import BotIdentity, fetch_bot_identity
+from .chat_mode import ChatModeCache
+from .comment import CommentPrimitiveClient
+from .config import (
+    ChannelConfig,
+    InboundConfig,
+    OutboundConfig,
+    PolicyConfig,
+    SafetyConfig,
+    SecurityConfig,
+    TransportConfig,
+    UATConfig,
+)
+from .driver import LarkClientDriver
+from .errors import FeishuChannelError, FeishuChannelErrorCode, OutboundSendError, SendError
+from .identity import IdentityResolver, NameCache
+from .keepalive import KeepaliveWatchdog
+from .media_cache import MediaResourceCache
+from .normalize.comment import normalize_comment
+from .normalize.dedup import Deduper, InMemoryDedupStore
+from .normalize.pipeline import InboundPipeline, PipelineConfig, PipelineDeps
+from .outbound.routing import infer_receive_id_type
+from .outbound.sender import OutboundSender
+from .outbound.streaming.card_stream import CardStreamController
+from .outbound.streaming.markdown_stream import MarkdownStreamController
+from .quote import QuoteResolver
+from .safety import RejectEvent, SafetyPipeline
+from .types import (
+    UAT,
+    BotAddedEvent,
+    BotLeaveEvent,
+    CachedResource,
+    CardActionEvent,
+    CardActionPayload,
+    ChatInfo,
+    CommentContext,
+    CommentTarget,
+    ConnectionSnapshot,
+    EventOperator,
+    MediaSource,
+    MessageReadEvent,
+    OutboundCard,
+    OutboundPost,
+    OutboundText,
+    ReactionEvent,
+    ResourceDescriptor,
+    SendResult,
+)
+
+EventHandler = Callable[..., Any]
+Unsubscribe = Callable[[], None]
+
+
+@dataclass
+class _SentMessageContext:
+    message_id: str
+    chat_id: str
+    chat_type: Optional[str] = None
+    receive_id_type: Optional[str] = None
+
+
+def _card_action_identity(action: Any) -> str:
+    """Stable dedup fragment for a card action.
+
+    Different buttons on the same card click to different ``(tag, value)``
+    pairs, and those must dedup-distinctly; a genuine WS redelivery of the
+    same click hashes identically and is suppressed.
+    """
+    tag = getattr(action, "tag", "") or ""
+    value = getattr(action, "value", None)
+    extras = {
+        key: getattr(action, key, None)
+        for key in ("form_value", "input_value", "options", "checked")
+        if getattr(action, key, None) is not None
+    }
+    if not extras:
+        value_repr = _legacy_card_action_value_identity(value)
+        return f"{tag}:{value_repr}"
+    value_repr = json.dumps(
+        _json_safe_identity_value(value),
+        sort_keys=True,
+        ensure_ascii=False,
+    )
+    extras_repr = json.dumps(
+        _json_safe_identity_value(extras),
+        sort_keys=True,
+        ensure_ascii=False,
+    )
+    return f"{tag}:{value_repr}:{extras_repr}"
+
+
+def _legacy_card_action_value_identity(value: Any) -> str:
+    try:
+        return json.dumps(value, sort_keys=True, ensure_ascii=False)
+    except (TypeError, ValueError):
+        return repr(value)
+
+
+def _json_safe_identity_value(value: Any, seen: Optional[Set[int]] = None) -> Any:
+    if value is None or isinstance(value, (str, int, float, bool)):
+        return value
+    if seen is None:
+        seen = set()
+    if isinstance(value, dict):
+        oid = id(value)
+        if oid in seen:
+            return "<cycle>"
+        seen.add(oid)
+        try:
+            return {
+                _json_safe_identity_key(key): _json_safe_identity_value(val, seen)
+                for key, val in value.items()
+            }
+        finally:
+            seen.discard(oid)
+    if isinstance(value, (list, tuple)):
+        oid = id(value)
+        if oid in seen:
+            return "<cycle>"
+        seen.add(oid)
+        try:
+            return [_json_safe_identity_value(item, seen) for item in value]
+        finally:
+            seen.discard(oid)
+    return f"<unserializable:{type(value).__name__}>"
+
+
+def _json_safe_identity_key(key: Any) -> str:
+    if isinstance(key, str):
+        return key
+    if key is None or isinstance(key, (int, float, bool)):
+        return str(key)
+    return f"<key:{type(key).__name__}>"
+
+
+def _extract_first_message_item(raw: Any) -> Optional[Dict[str, Any]]:
+    if not isinstance(raw, dict):
+        return None
+    data = raw.get("data")
+    if isinstance(data, dict):
+        items = data.get("items")
+        if isinstance(items, list) and items and isinstance(items[0], dict):
+            return items[0]
+        message = data.get("message")
+        if isinstance(message, dict):
+            return message
+    if raw.get("message_id"):
+        return raw
+    return None
+
+
+def _normalize_fetched_message_item(item: Dict[str, Any]) -> Dict[str, Any]:
+    msg = dict(item)
+    if not msg.get("message_type") and msg.get("msg_type"):
+        msg["message_type"] = msg.get("msg_type")
+    if msg.get("content") is None:
+        body = msg.get("body")
+        if isinstance(body, dict) and body.get("content") is not None:
+            msg["content"] = body.get("content")
+    return msg
+
+
+def _extract_fetched_sender(item: Dict[str, Any]) -> Any:
+    sender = item.get("sender")
+    if sender is not None:
+        if isinstance(sender, dict) and "sender_id" not in sender:
+            sender_id = {}
+            if sender.get("open_id"):
+                sender_id["open_id"] = sender.get("open_id")
+            if sender.get("user_id"):
+                sender_id["user_id"] = sender.get("user_id")
+            if sender.get("union_id"):
+                sender_id["union_id"] = sender.get("union_id")
+            raw_id = sender.get("id")
+            id_type = sender.get("id_type")
+            if raw_id:
+                if id_type == "user_id":
+                    sender_id.setdefault("user_id", raw_id)
+                elif id_type == "union_id":
+                    sender_id.setdefault("union_id", raw_id)
+                elif id_type in (None, "", "open_id"):
+                    sender_id.setdefault("open_id", raw_id)
+            if sender_id:
+                return {
+                    "sender_id": sender_id,
+                    "sender_type": sender.get("sender_type") or sender.get("type") or "user",
+                }
+        return sender
+    sender_id = item.get("sender_id")
+    if isinstance(sender_id, dict):
+        return {"sender_id": sender_id, "sender_type": item.get("sender_type") or "user"}
+    return {}
+
+
+# ---------------------------------------------------------------------------
+# FeishuChannel
+# ---------------------------------------------------------------------------
+
+
+class FeishuChannel:
+    """Single public entry point for the Feishu Channel capability layer.
+
+    Construct with flat keyword arguments for the common case::
+
+        channel = FeishuChannel(app_id="cli_xxx", app_secret="***")
+
+    Or tune any of the five functional areas (``policy`` / ``safety`` /
+    ``inbound`` / ``outbound`` / ``uat``) by passing a config dataclass::
+
+        from lark_channel import (
+            FeishuChannel, SafetyConfig, DedupConfig,
+            OutboundConfig, RetryConfig,
+        )
+
+        channel = FeishuChannel(
+            app_id="cli_xxx",
+            app_secret="***",
+            safety=SafetyConfig(dedup=DedupConfig(ttl_seconds=43_200)),
+            outbound=OutboundConfig(retry=RetryConfig(max_attempts=5)),
+        )
+
+    For pre-built full configs, pass ``config=ChannelConfig(...)``; per-area
+    kwargs override the fields they touch.
+    """
+
+    def __init__(
+        self,
+        *,
+        app_id: Optional[str] = None,
+        app_secret: Optional[str] = None,
+        encrypt_key: Optional[str] = None,
+        verification_token: Optional[str] = None,
+        domain: Optional[str] = None,
+        log_level: Optional[LogLevel] = None,
+        transport: Optional[Union[str, TransportConfig]] = None,
+        policy: Optional[PolicyConfig] = None,
+        safety: Optional[SafetyConfig] = None,
+        inbound: Optional[InboundConfig] = None,
+        outbound: Optional[OutboundConfig] = None,
+        uat: Optional[UATConfig] = None,
+        security: Optional[SecurityConfig] = None,
+        token_store: Optional[TokenStore] = None,
+        dedup_store: Any = None,
+        safety_cache: Optional[ICache] = None,
+        name_lookup: Optional[Callable[[List[str]], Any]] = None,
+        config: Optional[ChannelConfig] = None,
+    ) -> None:
+        """Create a channel.
+
+        ``dedup_store`` and ``safety_cache`` target **different** dedup
+        layers — this is a deliberate split, not a redundancy:
+
+        - ``dedup_store`` (:class:`~.normalize.dedup.DedupStore`) feeds the
+          *pipeline* ``Deduper`` that catches webhook retries + WS reconnect
+          backfill at the normalize step.
+        - ``safety_cache`` (:class:`~lark_channel.core.cache.ICache`, usually
+          Redis-backed) feeds the *safety* ``SeenCache`` used by
+          :class:`SafetyPipeline` for pre-dispatch dedup + (with an atomic
+          SETNX implementation) cross-process coherence.
+
+        Both default to in-memory when left as ``None``.
+        """
+        cfg = config if config is not None else ChannelConfig()
+        if app_id is not None:
+            cfg.app_id = app_id
+        if app_secret is not None:
+            cfg.app_secret = app_secret
+        if encrypt_key is not None:
+            cfg.encrypt_key = encrypt_key
+        if verification_token is not None:
+            cfg.verification_token = verification_token
+        if domain is not None:
+            cfg.domain = domain
+        if log_level is not None:
+            cfg.log_level = log_level
+        if policy is not None:
+            cfg.policy = policy
+        if safety is not None:
+            cfg.safety = safety
+        if inbound is not None:
+            cfg.inbound = inbound
+        if outbound is not None:
+            cfg.outbound = outbound
+        if uat is not None:
+            cfg.uat = uat
+        if security is not None:
+            cfg.security = security
+        if transport is not None:
+            if isinstance(transport, str):
+                if transport not in ("ws", "webhook"):
+                    raise ValueError(
+                        f"transport must be 'ws' or 'webhook', got {transport!r}"
+                    )
+                cfg.transport = TransportConfig(kind=transport)
+            else:
+                cfg.transport = transport
+        if not cfg.app_id or not cfg.app_secret:
+            raise ValueError("FeishuChannel requires app_id and app_secret")
+
+        self._config = cfg
+        self._safety_cache = safety_cache
+
+        self._client = (
+            Client.builder()
+            .app_id(cfg.app_id)
+            .app_secret(cfg.app_secret)
+            .domain(cfg.domain)
+            .log_level(cfg.log_level)
+            .timeout(cfg.transport.http_timeout_seconds)
+            .proxy_url(cfg.transport.proxy_url)
+            .trust_env_proxy(cfg.transport.trust_env_proxy)
+            .build()
+        )
+        # Mark all HTTP requests originating from this capability layer with a
+        # bare ``channel`` token in the User-Agent so the backend can attribute
+        # traffic to the channel SDK.
+        if self._client._config is not None:
+            self._client._config.extra_ua_tags = ["channel"]
+            self._client._config.security = cfg.security
+        self._driver = LarkClientDriver(self._client)
+        self._sender = OutboundSender(
+            driver=self._driver.send_driver(),
+            config=cfg.outbound,
+            on_success=self._track_sent_message,
+        )
+
+        self._dedup_store = dedup_store or InMemoryDedupStore(
+            max_entries=cfg.safety.dedup.max_entries
+        )
+        self._deduper = Deduper(
+            store=self._dedup_store,
+            ttl_seconds=cfg.safety.dedup.ttl_seconds,
+            enabled=cfg.safety.dedup.enabled,
+        )
+
+        self._identity_resolver = IdentityResolver(
+            lookup=name_lookup
+            or (lambda ids: _api_helpers.default_name_lookup(self._client, ids)),
+            cache=NameCache(cfg.inbound.name_cache),
+        )
+        self._chat_mode_cache = ChatModeCache(cfg.chat_mode_cache)
+        self._media_cache = MediaResourceCache(cfg.media_cache)
+
+        self._token_store: TokenStore = token_store or InMemoryTokenStore()
+        self._device_flow = DeviceFlowClient(
+            app_id=cfg.app_id,
+            app_secret=cfg.app_secret,
+            domain=cfg.domain,
+        )
+
+        self._pipeline = InboundPipeline(
+            cfg=PipelineConfig(
+                inbound=cfg.inbound, security=cfg.security, account_id=cfg.app_id
+            ),
+            deps=PipelineDeps(
+                fetch_message=self._fetch_message_payload,
+                resolve_names=self._identity_resolver.resolve_names,
+                resolve_identity=self._identity_resolver.resolve,
+            ),
+            deduper=self._deduper,
+        )
+        self._pipeline.set_chat_mode_resolver(self.get_chat_mode)
+
+        self._safety: Optional[SafetyPipeline] = None
+
+        # String-event handlers. Multiple handlers per event name are appended
+        # in registration order; `_invoke` iterates them all.
+        self._handlers: Dict[str, List[EventHandler]] = {}
+
+        self._dispatcher: Optional[EventDispatcherHandler] = None
+        self._ws_client: Optional[WSClient] = None
+
+        self._bot_identity: Optional[BotIdentity] = None
+        self._bot_open_id: Optional[str] = None
+        # Guards reads / writes to ``_bot_identity`` + ``_bot_open_id`` +
+        # ``_safety.set_bot_open_id`` so the initial fetch, an explicit
+        # ``await resolve_bot_identity()``, and the background retry loop
+        # can't leave the two fields in a half-updated state when a reader
+        # on the bg loop is inspecting them.
+        self._bot_identity_lock = threading.Lock()
+        self._bot_identity_retry_future: Optional[concurrent.futures.Future] = None
+
+        self._sent_messages: "OrderedDict[str, float]" = OrderedDict()
+        self._sent_message_context: "OrderedDict[str, _SentMessageContext]" = OrderedDict()
+        self._sent_messages_max = 2048
+        self._start_future: Optional[asyncio.Future] = None
+
+        self._bg_loop: Optional[asyncio.AbstractEventLoop] = None
+        self._bg_thread: Optional[threading.Thread] = None
+        # Guards start/stop of the bg loop so concurrent connect() calls can't
+        # spawn two loops + two threads.
+        self._bg_lock = threading.Lock()
+
+        # References to Futures returned by `schedule(...)` — kept alive so
+        # exceptions surface (done callback logs) and so shutdown can drain /
+        # cancel in-flight work.
+        self._bg_tasks: Set[concurrent.futures.Future] = set()
+        self._bg_tasks_lock = threading.Lock()
+
+        self._shutdown = threading.Event()
+        self._stop_requested = False
+        self._started = False
+        self._lifecycle_lock = threading.Lock()
+        self._lifecycle_generation = 0
+        self._background_generation = 0
+        # Lazy-init: asyncio.Event() in older Python (<3.10) requires a
+        # running loop; create on first access from a coroutine context.
+        self._ready_event: Optional[asyncio.Event] = None
+        self._ready_flag: bool = False
+        self._connection_state: str = "idle"
+        self._connection_reconnect_attempts: int = 0
+        self._connection_last_connected_at: Optional[float] = None
+        self._connection_last_disconnected_at: Optional[float] = None
+        self._connection_last_error_at: Optional[float] = None
+        self._connection_last_error: Optional[str] = None
+        self._keepalive_watchdog: Optional[KeepaliveWatchdog] = None
+        self._keepalive_future: Optional[concurrent.futures.Future] = None
+
+    # ------------------------------------------------------------------
+    # Event registration
+    # ------------------------------------------------------------------
+    def on(
+        self,
+        name_or_map: Union[ChannelEventName, Dict[ChannelEventName, EventHandler]],
+        handler: Optional[EventHandler] = None,
+    ) -> Unsubscribe:
+        """Register an event handler.
+
+        Accepts ``on(event_name, handler)`` or ``on({event_name: handler})``.
+        Returns an unsubscribe callable that pops exactly this handler from
+        the list.
+
+        ``name_or_map`` is type-hinted with :data:`.events.ChannelEventName`
+        so static type checkers catch typos (e.g. ``"messageReceive"`` vs
+        the correct ``"message"``). At runtime, unknown names produce a
+        warning log but do not raise — several historical aliases are still
+        accepted via :mod:`._coerce`.
+        """
+        if isinstance(name_or_map, dict):
+            subs = [self._register_single(k, v) for k, v in name_or_map.items() if v]
+            return lambda: [u() for u in subs]
+        if handler is None:
+            raise TypeError(
+                "FeishuChannel.on expects a handler when called with an event name"
+            )
+        return self._register_single(name_or_map, handler)
+
+    def _register_single(self, name: str, handler: EventHandler) -> Unsubscribe:
+        normalized = _coerce.normalize_event_name(name)
+        if normalized not in _coerce.VALID_EVENTS:
+            logger.warning("FeishuChannel.on: unknown event %r", name)
+        self._handlers.setdefault(normalized, []).append(handler)
+
+        def unsubscribe() -> None:
+            lst = self._handlers.get(normalized)
+            if not lst:
+                return
+            try:
+                lst.remove(handler)
+            except ValueError:
+                return
+            if not lst:
+                self._handlers.pop(normalized, None)
+
+        return unsubscribe
+
+    async def _invoke(self, name: str, *args) -> None:
+        handlers = self._handlers.get(_coerce.normalize_event_name(name))
+        if not handlers:
+            return
+        # Iterate a snapshot so handlers unsubscribing themselves mid-invoke
+        # don't mutate the list we're walking.
+        for handler in list(handlers):
+            try:
+                result = handler(*args)
+                if inspect.isawaitable(result):
+                    await result
+            except Exception as e:
+                logger.exception(
+                    "FeishuChannel: handler for %r raised: %s", name, e
+                )
+                for err in self._handlers.get("error", []):
+                    try:
+                        res = err(e)
+                        if inspect.isawaitable(res):
+                            await res
+                    except Exception:  # pragma: no cover
+                        pass
+
+    # ------------------------------------------------------------------
+    # Properties / escape hatches
+    # ------------------------------------------------------------------
+    @property
+    def client(self) -> Client:
+        """The underlying OpenAPI ``Client``."""
+        return self._client
+
+    @property
+    def ws_client(self) -> Optional[WSClient]:
+        """The WebSocket client if the channel was started in ``ws`` mode."""
+        return self._ws_client
+
+    @property
+    def bot_identity(self) -> Optional[BotIdentity]:
+        """Currently-resolved bot identity, or ``None`` if not yet fetched.
+
+        Read under the same lock that guards writes so callers never observe
+        a half-updated state (``_bot_identity`` fresh but ``_bot_open_id``
+        stale or vice-versa).
+        """
+        with self._bot_identity_lock:
+            return self._bot_identity
+
+    @property
+    def config(self) -> ChannelConfig:
+        return self._config
+
+    @property
+    def safety(self) -> Optional[SafetyPipeline]:
+        return self._safety
+
+    @property
+    def sender(self) -> OutboundSender:
+        return self._sender
+
+    @property
+    def driver(self) -> LarkClientDriver:
+        return self._driver
+
+    @property
+    def dispatcher(self) -> EventDispatcherHandler:
+        if self._dispatcher is None:
+            self._dispatcher = self._build_dispatcher()
+        return self._dispatcher
+
+    async def handle_webhook_request(
+        self,
+        headers: "Mapping[str, str]",
+        body: bytes,
+    ) -> "tuple[int, bytes]":
+        """Process a single inbound webhook request.
+
+        This is the framework-agnostic entry point — wrap with aiohttp /
+        starlette / fastapi / your favorite web layer. The SDK does not ship
+        a built-in webhook server; rate limiting, anomaly tracking, and IP
+        allowlisting are deployment concerns that live in your service.
+
+        Behavior:
+
+        - Decrypts the body using ``encrypt_key`` (if configured).
+        - Verifies the request via ``verification_token`` (if configured).
+        - Verifies the request signature against the headers (when
+          ``encrypt_key`` is set, the dispatcher checks
+          ``X-Lark-Request-Timestamp`` / ``X-Lark-Request-Nonce`` /
+          ``X-Lark-Signature``).
+        - Routes the event to your registered ``channel.on(...)`` handlers.
+
+        Args:
+            headers: HTTP request headers (typically a dict-like; case
+                sensitivity follows your framework's conventions).
+            body: Raw HTTP request body bytes.
+
+        Returns:
+            ``(status_code, response_body_bytes)`` — write the body straight
+            back to your HTTP response.
+
+        Raises:
+            FeishuChannelError(NOT_CONNECTED): When called before ``start()``.
+                The dispatcher converts bad-token / signature failures to a
+                500 response body itself; this method does not raise on those.
+        """
+        if self._dispatcher is None:
+            raise FeishuChannelError(
+                FeishuChannelErrorCode.NOT_CONNECTED,
+                "handle_webhook_request called before start() — dispatcher missing",
+            )
+
+        from lark_channel.core.model.raw_request import RawRequest
+        req = RawRequest()
+        req.uri = "/webhook"
+        req.headers = dict(headers) if headers else {}
+        req.body = body
+
+        # The dispatcher's `do` is sync; offload so we don't block the
+        # caller's event loop on signature verification + JSON parse.
+        loop = asyncio.get_running_loop()
+        resp = await loop.run_in_executor(None, self._dispatcher.do, req)
+        status = getattr(resp, "status_code", 200) or 200
+        content = getattr(resp, "content", b"")
+        if isinstance(content, str):
+            content = content.encode("utf-8")
+        if not isinstance(content, (bytes, bytearray)):
+            content = bytes(content) if content is not None else b""
+        return status, content
+
+    def get_policy(self) -> PolicyConfig:
+        return self._config.policy
+
+    def update_policy(self, **changes) -> None:
+        if self._safety is not None:
+            self._safety.update_policy(**changes)
+        for k, v in changes.items():
+            if hasattr(self._config.policy, k):
+                setattr(self._config.policy, k, v)
+
+    # ------------------------------------------------------------------
+    # Readiness
+    # ------------------------------------------------------------------
+    @property
+    def is_ready(self) -> bool:
+        """True after start() has fully initialized.
+
+        Specifically: WS connect has succeeded (or webhook dispatcher is
+        constructed), bot identity is resolved (or its retry loop is running),
+        and the safety pipeline is initialized. Events received before this
+        point are NOT dispatched to user handlers — they are dropped (the
+        WS-reconnect backfill or webhook retries cover startup-window losses).
+        """
+        return self._ready_flag
+
+    async def wait_ready(self, *, timeout: Optional[float] = None) -> None:
+        """Block until is_ready turns True. Raises asyncio.TimeoutError on timeout."""
+        ev = self._ensure_ready_event()
+        if self._ready_flag:
+            return
+        if timeout is None:
+            await ev.wait()
+            return
+        await asyncio.wait_for(ev.wait(), timeout=timeout)
+
+    def _mark_ready(self) -> None:
+        """Internal: flip the readiness event. Called at the end of start()
+        after WS connect, bot identity fetch, and safety pipeline init.
+        Idempotent.
+        """
+        self._ready_flag = True
+        self._connection_state = "connected"
+        self._connection_last_connected_at = time.time()
+        ev = self._ready_event
+        if ev is not None:
+            try:
+                ev.set()
+            except Exception:  # pragma: no cover
+                pass
+
+    def _ensure_ready_event(self) -> "asyncio.Event":
+        """Lazily create the asyncio.Event so we don't need a running loop in __init__."""
+        if self._ready_event is None:
+            self._ready_event = asyncio.Event()
+            if self._ready_flag:
+                self._ready_event.set()
+        return self._ready_event
+
+    # ------------------------------------------------------------------
+    # Lifecycle
+    # ------------------------------------------------------------------
+    async def connect(self) -> None:
+        """Idempotent. Blocks until WS connects or Webhook dispatcher is ready."""
+        if getattr(self, "_started", False):
+            return
+        await asyncio.get_running_loop().run_in_executor(None, self.start)
+
+    async def start_background(self, *, timeout: Optional[float] = 30.0) -> None:
+        """Start transport in the background and return once it is ready.
+
+        ``connect()`` keeps the historical foreground/blocking WebSocket
+        behavior. Async applications that need startup to continue after the
+        WebSocket handshake should use this method instead.
+        """
+        if self._ready_flag:
+            return
+        loop = asyncio.get_running_loop()
+        if self._start_future is None or self._start_future.done():
+            with self._lifecycle_lock:
+                self._stop_requested = False
+                self._background_generation += 1
+                background_generation = self._background_generation
+            self._start_future = loop.run_in_executor(None, self.start)
+        else:
+            with self._lifecycle_lock:
+                background_generation = self._background_generation
+        await self._wait_background_start_ready(
+            timeout=timeout,
+            generation=background_generation,
+        )
+
+    async def connect_until_ready(self, *, timeout: Optional[float] = 30.0) -> None:
+        """Alias for :meth:`start_background` with explicit ready semantics."""
+        await self.start_background(timeout=timeout)
+
+    async def stop_background(self) -> None:
+        """Stop a channel started by :meth:`start_background`.
+
+        This is equivalent to :meth:`disconnect`; it is provided as the
+        lifecycle counterpart to ``start_background``.
+        """
+        await self.disconnect()
+
+    async def _wait_background_start_ready(
+        self,
+        *,
+        timeout: Optional[float],
+        generation: int,
+    ) -> None:
+        loop = asyncio.get_running_loop()
+        deadline = None if timeout is None else loop.time() + timeout
+        while True:
+            if self._ready_flag:
+                return
+            if generation != self._background_generation:
+                return
+            if self._stop_requested:
+                return
+            fut = self._start_future
+            if fut is None:
+                await asyncio.sleep(0.05)
+                continue
+            if fut is not None and fut.done():
+                if fut.cancelled():
+                    if generation != self._background_generation or self._stop_requested:
+                        return
+                    raise FeishuChannelError(
+                        FeishuChannelErrorCode.NOT_CONNECTED,
+                        "Channel background start was cancelled",
+                    )
+                exc = fut.exception()
+                if exc is not None:
+                    raise exc
+                if self._ready_flag or self._config.transport.kind == "webhook":
+                    return
+                raise FeishuChannelError(
+                    FeishuChannelErrorCode.NOT_CONNECTED,
+                    "Channel start exited before transport became ready",
+                )
+            ws = self._ws_client
+            if ws is not None and getattr(ws, "_conn", None) is not None:
+                self._mark_ready()
+                return
+            if deadline is not None and loop.time() >= deadline:
+                self.stop()
+                raise FeishuChannelError(
+                    FeishuChannelErrorCode.NOT_CONNECTED,
+                    "Timed out waiting for channel transport readiness",
+                )
+            await asyncio.sleep(0.05)
+
+    async def disconnect(self) -> None:
+        """Gracefully drain safety pipeline batches + stop the WS loop."""
+        if self._safety is not None:
+            try:
+                await self._safety.dispose()
+            except Exception:  # pragma: no cover
+                pass
+        self.stop()
+
+    def start(self) -> None:
+        """Start WS (blocking) or return after initializing Webhook dispatcher.
+
+        Transport-level failures (bad credentials, network unreachable, TLS
+        handshake failure, ...) are wrapped into
+        :class:`FeishuChannelError(NOT_CONNECTED)` with the original
+        exception chained via ``__cause__``. This gives callers a stable,
+        ``code``-bearing exception to match on instead of whatever raw
+        exception the underlying transport happens to raise (e.g.
+        ``lark_channel.ws.client.ClientException`` whose ``.code`` is an int).
+        """
+        if self._started:
+            return
+        with self._lifecycle_lock:
+            self._lifecycle_generation += 1
+            generation = self._lifecycle_generation
+            self._stop_requested = False
+            self._started = True
+        self._ensure_bg_loop()
+        self._fetch_bot_identity_sync()
+        self._dispatcher = self._build_dispatcher()
+        if self._config.transport.kind == "webhook":
+            with self._lifecycle_lock:
+                if not self._is_active_start(generation):
+                    return
+                logger.info(
+                    "FeishuChannel: webhook mode ready — pass `dispatcher` to your HTTP adaptor"
+                )
+                self._mark_ready()
+            return
+        with self._lifecycle_lock:
+            if not self._is_active_start(generation):
+                return
+            self._ws_client = WSClient(
+                self._config.app_id,
+                self._config.app_secret,
+                log_level=self._config.log_level,
+                event_handler=self._dispatcher,
+                domain=self._config.domain,
+                auto_reconnect=self._config.transport.auto_reconnect,
+                extra_ua_tags=["channel"],
+                headers=self._config.transport.headers,
+                proxy_url=self._config.transport.proxy_url,
+                trust_env_proxy=self._config.transport.trust_env_proxy,
+                handshake_timeout=self._config.transport.handshake_timeout_seconds,
+                security=self._config.security,
+            )
+            # Wire transport-level reconnect events to the public ``on()`` bus so
+            # callers registering ``on("reconnecting", ...) / on("reconnected", ...)``
+            # actually observe them.
+            self._ws_client.on_reconnecting = self._notify_reconnecting
+            self._ws_client.on_reconnected = self._notify_reconnected
+            self._start_keepalive_watchdog()
+        try:
+            self._ws_client.start()
+        except FeishuChannelError:
+            # Already the right shape; just reset started so caller can retry.
+            self._cleanup_failed_start(generation)
+            raise
+        except Exception as e:
+            if not self._is_active_start(generation):
+                self._cleanup_failed_start(generation)
+                return
+            # Anything else (ws client's ClientException, timeouts, DNS, ...)
+            # → typed NOT_CONNECTED so callers can ``except FeishuChannelError
+            # as err: if err.code == FeishuChannelErrorCode.NOT_CONNECTED``.
+            self._record_connection_error(e)
+            self._cleanup_failed_start(generation)
+            raise FeishuChannelError(
+                FeishuChannelErrorCode.NOT_CONNECTED,
+                f"WebSocket connect failed: {e}",
+            ) from e
+        with self._lifecycle_lock:
+            if not self._is_active_start(generation):
+                self._stop_keepalive_watchdog()
+                return
+            self._mark_ready()
+
+    def _is_active_start(self, generation: int) -> bool:
+        if (
+            generation != self._lifecycle_generation
+            or self._shutdown.is_set()
+            or self._stop_requested
+        ):
+            if generation == self._lifecycle_generation:
+                self._started = False
+            return False
+        return True
+
+    def _cleanup_failed_start(self, generation: int) -> None:
+        self._stop_keepalive_watchdog()
+        ws = self._ws_client
+        if ws is not None:
+            stopped = False
+            for meth in ("stop", "close", "disconnect"):
+                fn = getattr(ws, meth, None)
+                if callable(fn):
+                    try:
+                        fn()
+                    except Exception as e:  # pragma: no cover
+                        logger.warning(
+                            "FeishuChannel.start: ws.%s raised during cleanup: %s",
+                            meth,
+                            e,
+                        )
+                    stopped = True
+                    break
+            if not stopped:
+                self._stop_private_ws_client(ws)
+        self._cancel_bg_tasks()
+        self._stop_bg_loop(join_timeout=2.0)
+        with self._lifecycle_lock:
+            if generation == self._lifecycle_generation:
+                self._started = False
+                self._ready_flag = False
+                self._connection_state = "error"
+                self._ws_client = None
+                self._safety = None
+
+    def stop(self, *, join_timeout: float = 5.0) -> None:
+        """Tear down everything the channel owns.
+
+        Safe to call from any thread, idempotent. Steps:
+
+        1. Signal shutdown (sets ``self._shutdown``).
+        2. Stop the WS client if one was created.
+        3. Cancel in-flight futures returned from :meth:`schedule`.
+        4. Run ``DeviceFlowClient.close()`` on the bg loop to release httpx.
+        5. Stop the bg loop and join its thread.
+        """
+        if self._shutdown.is_set():
+            return
+        self._shutdown.set()
+        if self._start_future is not None:
+            try:
+                self._start_future.cancel()
+            except Exception:  # pragma: no cover
+                pass
+        self._stop_keepalive_watchdog()
+
+        # 1. Stop WS client (best-effort; some builds don't expose stop()).
+        with self._lifecycle_lock:
+            self._background_generation += 1
+            self._lifecycle_generation += 1
+            self._stop_requested = True
+            ws = self._ws_client
+        if ws is not None:
+            stopped = False
+            for meth in ("stop", "close", "disconnect"):
+                fn = getattr(ws, meth, None)
+                if callable(fn):
+                    try:
+                        fn()
+                    except Exception as e:  # pragma: no cover
+                        logger.warning("FeishuChannel.stop: ws.%s raised: %s", meth, e)
+                    stopped = True
+                    break
+            if not stopped:
+                self._stop_private_ws_client(ws)
+
+        # 2. Cancel scheduled futures.
+        self._cancel_bg_tasks()
+
+        # 3. Close httpx client inside device_flow via the bg loop (if up).
+        if self._bg_loop is not None and self._bg_loop.is_running():
+            try:
+                close_fut = asyncio.run_coroutine_threadsafe(
+                    self._device_flow.close(), self._bg_loop
+                )
+                try:
+                    close_fut.result(timeout=2.0)
+                except (concurrent.futures.TimeoutError, Exception) as e:  # pragma: no cover
+                    logger.warning("FeishuChannel.stop: device_flow.close timed out: %s", e)
+            except RuntimeError:  # pragma: no cover - loop closed between checks
+                pass
+
+        # 4. Stop the bg loop + join thread.
+        self._stop_bg_loop(join_timeout=join_timeout)
+        self._ws_client = None
+        self._start_future = None
+
+        # Allow a subsequent connect()/start() to actually run. Without
+        # clearing these two flags, a channel that was stopped would be
+        # permanently inert — any future connect() would short-circuit on
+        # ``self._started`` and ``_ensure_bg_loop`` would refuse on the
+        # persisted ``_shutdown``.
+        self._shutdown.clear()
+        self._started = False
+        self._ready_flag = False
+        self._connection_state = "idle"
+        self._connection_last_disconnected_at = time.time()
+        if self._ready_event is not None:
+            try:
+                self._ready_event.clear()
+            except Exception:  # pragma: no cover
+                pass
+        with self._bg_tasks_lock:
+            self._bg_tasks.clear()
+
+    def _stop_private_ws_client(self, ws: Any) -> None:
+        disconnect = getattr(ws, "_disconnect", None)
+        try:
+            from lark_channel.ws import client as ws_client_module
+
+            ws_loop = getattr(ws_client_module, "loop", None)
+            if callable(disconnect) and ws_loop is not None:
+                if ws_loop.is_running():
+                    try:
+                        running_loop = asyncio.get_running_loop()
+                    except RuntimeError:
+                        running_loop = None
+                    if running_loop is ws_loop:
+                        ws_loop.create_task(disconnect())
+                    else:
+                        fut = asyncio.run_coroutine_threadsafe(disconnect(), ws_loop)
+                        try:
+                            fut.result(timeout=2.0)
+                        except Exception as e:  # pragma: no cover
+                            logger.warning("FeishuChannel.stop: ws._disconnect timed out: %s", e)
+                elif not ws_loop.is_closed():
+                    ws_loop.run_until_complete(disconnect())
+            if ws_loop is not None and ws_loop.is_running():
+                ws_loop.call_soon_threadsafe(ws_loop.stop)
+        except Exception as e:  # pragma: no cover
+            logger.warning("FeishuChannel.stop: private ws shutdown raised: %s", e)
+
+    def schedule(self, coro) -> "concurrent.futures.Future":
+        """Submit a coroutine to the background loop; safe from any thread.
+
+        The returned Future is also tracked internally so exceptions surface
+        via a logging done-callback (no more fire-and-forget) and so
+        :meth:`stop` can cancel in-flight work. Callers may still ignore the
+        return value.
+        """
+        self._ensure_bg_loop()
+        if self._bg_loop is None:
+            raise RuntimeError("FeishuChannel: background loop is not running")
+        try:
+            fut = asyncio.run_coroutine_threadsafe(coro, self._bg_loop)
+        except RuntimeError as e:  # pragma: no cover - loop closed
+            logger.warning("FeishuChannel: schedule failed: %s", e)
+            raise
+        with self._bg_tasks_lock:
+            self._bg_tasks.add(fut)
+
+        def _done(f: "concurrent.futures.Future") -> None:
+            with self._bg_tasks_lock:
+                self._bg_tasks.discard(f)
+            if f.cancelled():
+                return
+            exc = f.exception()
+            if exc is not None:
+                logger.exception(
+                    "FeishuChannel.schedule: background task raised: %s", exc,
+                    exc_info=exc,
+                )
+
+        fut.add_done_callback(_done)
+        return fut
+
+    def _call_safety_threadsafe(self, method_name: str, *args) -> None:
+        self._ensure_bg_loop()
+        loop = self._bg_loop
+        if loop is None or getattr(loop, "is_closed", lambda: False)():
+            raise RuntimeError("FeishuChannel: background loop is not running")
+        try:
+            running_loop = asyncio.get_running_loop()
+        except RuntimeError:
+            running_loop = None
+        safety = self._safety
+        if safety is None:
+            if running_loop is loop:
+                raise RuntimeError("FeishuChannel: safety pipeline is not running")
+            for _ in range(50):
+                time.sleep(0.01)
+                safety = self._safety
+                if safety is not None:
+                    break
+        if safety is None:
+            raise RuntimeError("FeishuChannel: safety pipeline is not running")
+        fn = getattr(safety, method_name)
+        try:
+            if running_loop is loop:
+                fn(*args)
+            elif loop.is_running():
+                loop.call_soon_threadsafe(fn, *args)
+            else:
+                fn(*args)
+        except RuntimeError as e:
+            raise RuntimeError("FeishuChannel: background loop is not running") from e
+
+    def block_batch_scope(self, scope: str) -> None:
+        self._call_safety_threadsafe("block_batch_scope", scope)
+
+    def unblock_batch_scope(self, scope: str) -> None:
+        self._call_safety_threadsafe("unblock_batch_scope", scope)
+
+    def cancel_batch_scope(self, scope: str) -> None:
+        self._call_safety_threadsafe("cancel_batch_scope", scope)
+
+    def _start_keepalive_watchdog(self) -> None:
+        keepalive_cfg = self._config.transport.keepalive
+        ws = self._ws_client
+        if not keepalive_cfg.enabled or ws is None:
+            return
+        if self._keepalive_future is not None and not self._keepalive_future.done():
+            return
+        self._keepalive_watchdog = KeepaliveWatchdog(
+            config=keepalive_cfg,
+            probe=lambda: ws.probe_endpoint(timeout=keepalive_cfg.probe_timeout_seconds),
+            reconnect=lambda: ws.request_reconnect(),
+        )
+        self._keepalive_future = self.schedule(self._keepalive_loop())
+
+    def _stop_keepalive_watchdog(self) -> None:
+        future = self._keepalive_future
+        self._keepalive_watchdog = None
+        self._keepalive_future = None
+        if future is None:
+            return
+        try:
+            future.cancel()
+        except Exception:  # pragma: no cover
+            pass
+
+    async def _keepalive_loop(self) -> None:
+        while not self._shutdown.is_set():
+            cfg = self._config.transport.keepalive
+            await asyncio.sleep(cfg.check_interval_seconds)
+            watchdog = self._keepalive_watchdog
+            if watchdog is not None:
+                await watchdog.run_once()
+
+    # Backoff schedule used by :meth:`_start_bot_identity_retry_loop`.
+    # Covers roughly 1h 15m of retries: 10s, 30s, 2m, 10m, 1h. After that we
+    # give up and log once at ERROR; a caller can always invoke
+    # :meth:`resolve_bot_identity` manually to try again.
+    _BOT_IDENTITY_RETRY_DELAYS_S = (10, 30, 120, 600, 3600)
+
+    def _store_bot_identity(self, identity: Optional[BotIdentity]) -> None:
+        """Atomically swap in a fresh bot identity + propagate to safety."""
+        with self._bot_identity_lock:
+            self._bot_identity = identity
+            self._bot_open_id = identity.open_id if identity is not None else None
+            self._pipeline.set_bot_open_id(self._bot_open_id)
+            safety = self._safety
+            if safety is not None and identity is not None:
+                safety.set_bot_open_id(identity.open_id)
+
+    async def resolve_bot_identity(self) -> Optional[BotIdentity]:
+        """Fetch the bot identity + publish it to readers under a lock.
+
+        Safe to call from any loop. Returns the resolved identity (or None if
+        the upstream call failed — callers that need the identity should
+        react to None by retrying later).
+        """
+        identity = await fetch_bot_identity(self._client.config)
+        if identity is not None:
+            self._store_bot_identity(identity)
+        return identity
+
+    def _fetch_bot_identity_sync(self) -> None:
+        if self._bg_loop is None:
+            raise RuntimeError("FeishuChannel: background loop is not running")
+        fut = asyncio.run_coroutine_threadsafe(
+            fetch_bot_identity(self._client.config), self._bg_loop
+        )
+        try:
+            identity = fut.result(timeout=10)
+        except Exception as e:
+            logger.warning("FeishuChannel: bot identity fetch failed: %s", e)
+            identity = None
+        if identity is None:
+            # A transient network hiccup at startup can leave group ``@Bot``
+            # detection unavailable until identity resolves. Schedule a
+            # background backoff retry loop instead of treating startup lookup
+            # as the only chance to populate ``_bot_open_id``.
+            logger.warning(
+                "FeishuChannel: bot identity unresolved on startup — "
+                "scheduling background retry (group @Bot detection will "
+                "remain off until resolved)"
+            )
+            self._start_bot_identity_retry_loop()
+            return
+        self._store_bot_identity(identity)
+        logger.info(
+            "FeishuChannel: bot identity resolved — open_id=%s name=%s",
+            identity.open_id, identity.name,
+        )
+
+    def _start_bot_identity_retry_loop(self) -> None:
+        """Schedule a backoff retry task on the bg loop."""
+        future = self._bot_identity_retry_future
+        if future is not None and not future.done():
+            return
+        if self._bg_loop is None:
+            return
+        coro = self._bot_identity_retry_loop()
+        try:
+            self._bot_identity_retry_future = self.schedule(coro)
+        except RuntimeError:  # pragma: no cover - loop already stopped
+            coro.close()
+            pass
+
+    def _cancel_bg_tasks(self) -> None:
+        with self._bg_tasks_lock:
+            pending = list(self._bg_tasks)
+        retry_future = self._bot_identity_retry_future
+        if retry_future is not None and retry_future not in pending:
+            pending.append(retry_future)
+        for fut in pending:
+            try:
+                fut.cancel()
+            except Exception:  # pragma: no cover
+                pass
+        self._drain_cancelled_bg_tasks()
+
+    def _stop_bg_loop(self, *, join_timeout: float) -> None:
+        loop = self._bg_loop
+        thread = self._bg_thread
+        if loop is not None:
+            try:
+                loop.call_soon_threadsafe(loop.stop)
+            except RuntimeError:  # pragma: no cover - already stopped
+                pass
+        if (
+            thread is not None
+            and thread.is_alive()
+            and thread is not threading.current_thread()
+        ):
+            thread.join(timeout=join_timeout)
+            if thread.is_alive():  # pragma: no cover
+                logger.warning(
+                    "FeishuChannel.stop: bg thread did not exit within %.1fs",
+                    join_timeout,
+                )
+        self._bg_loop = None
+        self._bg_thread = None
+
+    async def _bot_identity_retry_loop(self) -> None:
+        """Retry ``fetch_bot_identity`` on a backoff schedule until it
+        succeeds, shutdown fires, or we exhaust the delay table."""
+        for delay_s in self._BOT_IDENTITY_RETRY_DELAYS_S:
+            try:
+                await asyncio.sleep(delay_s)
+            except asyncio.CancelledError:
+                raise
+            if self._shutdown.is_set():
+                return
+            # Someone else (manual resolve_bot_identity call) may have
+            # already filled it in — bail out without a pointless fetch.
+            with self._bot_identity_lock:
+                if self._bot_identity is not None:
+                    return
+            try:
+                identity = await fetch_bot_identity(self._client.config)
+            except Exception as e:
+                logger.warning(
+                    "FeishuChannel: bot identity retry failed (delay=%ds): %s",
+                    delay_s, e,
+                )
+                continue
+            if identity is not None:
+                self._store_bot_identity(identity)
+                logger.info(
+                    "FeishuChannel: bot identity resolved on retry — open_id=%s",
+                    identity.open_id,
+                )
+                return
+        logger.error(
+            "FeishuChannel: bot identity still unresolved after all retries — "
+            "group @Bot detection is disabled for this process; call "
+            "channel.resolve_bot_identity() manually to try again"
+        )
+
+    def _drain_cancelled_bg_tasks(self) -> None:
+        loop = self._bg_loop
+        if loop is None or not loop.is_running():
+            return
+        try:
+            drain_fut = asyncio.run_coroutine_threadsafe(asyncio.sleep(0), loop)
+            drain_fut.result(timeout=0.5)
+        except Exception:  # pragma: no cover
+            pass
+
+    def _ensure_bg_loop(self) -> None:
+        # Double-checked locking: the outer check avoids the lock in the hot
+        # path, the inner check prevents a race between two concurrent
+        # callers both seeing None and each spawning their own loop+thread.
+        if self._bg_loop is not None:
+            return
+        with self._bg_lock:
+            if self._bg_loop is not None:
+                return
+            if self._shutdown.is_set():
+                raise RuntimeError(
+                    "FeishuChannel._ensure_bg_loop: channel is shutting down"
+                )
+            loop = asyncio.new_event_loop()
+
+            def _runner() -> None:
+                asyncio.set_event_loop(loop)
+                try:
+                    loop.run_forever()
+                finally:
+                    try:
+                        loop.close()
+                    except Exception:  # pragma: no cover
+                        pass
+
+            t = threading.Thread(target=_runner, name="lark-channel-bg", daemon=True)
+            t.start()
+            self._bg_loop = loop
+            self._bg_thread = t
+
+        async def _build_safety():
+            safety_cfg = self._config.safety
+            return SafetyPipeline(
+                loop=self._bg_loop,
+                on_message=self._dispatch_inbound_to_user,
+                on_reject=self._emit_reject,
+                policy=self._config.policy,
+                # Safety-layer dedup cache (ICache, usually Redis) — wired
+                # explicitly from the constructor kwarg, independent of the
+                # pipeline-layer DedupStore that feeds `self._deduper`.
+                cache=self._safety_cache,
+                dedup_config=safety_cfg.dedup,
+                batch_config=safety_cfg.text_batch,
+                media_batch_config=safety_cfg.media_batch,
+                queue_config=safety_cfg.chat_queue,
+                stale_window_ms=safety_cfg.stale_message_window_ms,
+                drop_self_sent=self._config.inbound.drop_self_sent,
+            )
+
+        fut = asyncio.run_coroutine_threadsafe(_build_safety(), self._bg_loop)
+        self._safety = fut.result(timeout=5)
+        with self._bot_identity_lock:
+            open_id = self._bot_open_id
+        if open_id:
+            self._safety.set_bot_open_id(open_id)
+
+    # ------------------------------------------------------------------
+    # Dispatcher
+    # ------------------------------------------------------------------
+    def _build_dispatcher(self) -> EventDispatcherHandler:
+        b = EventDispatcherHandler.builder(
+            self._config.encrypt_key or "",
+            self._config.verification_token or "",
+            self._config.log_level,
+            security=self._config.security,
+        )
+        b = b.register_p2_im_message_receive_v1(self._on_p2_im_message_receive_v1)
+        b = b.register_p2_card_action_trigger(self._on_p2_card_action_trigger)
+        for register, handler in (
+            ("register_p2_im_message_reaction_created_v1", self._on_p2_reaction_created),
+            ("register_p2_im_message_reaction_deleted_v1", self._on_p2_reaction_deleted),
+            ("register_p2_im_chat_member_bot_added_v1", self._on_p2_bot_added),
+            ("register_p2_im_chat_member_bot_deleted_v1", self._on_p2_bot_deleted),
+            ("register_p2_im_message_message_read_v1", self._on_p2_message_read),
+        ):
+            try:
+                b = getattr(b, register)(handler)
+            except Exception:  # pragma: no cover
+                pass
+        # drive.notice.comment_add_v1 has no typed processor in the
+        # generated SDK. The wire payload may arrive under either schema:
+        # the legacy callback channel uses p1 (event has ``uuid``), but
+        # the modern WS frontier wraps the same event in a p2 envelope
+        # (``schema=2.0``). Register the customized-event handler under
+        # both so neither path logs "processor not found".
+        b = b.register_p1_customized_event(
+            "drive.notice.comment_add_v1", self._on_p1_comment_add
+        )
+        b = b.register_p2_customized_event(
+            "drive.notice.comment_add_v1", self._on_p1_comment_add
+        )
+        return b.build()
+
+    # ------------------------------------------------------------------
+    # Raw sync entry points — schedule async work on the bg loop
+    # ------------------------------------------------------------------
+    def _on_p2_im_message_receive_v1(self, data: Any) -> None:
+        self.schedule(self._handle_message_event(data))
+
+    def _on_p2_card_action_trigger(
+        self, data: P2CardActionTrigger
+    ) -> P2CardActionTriggerResponse:
+        try:
+            if "cardAction" in self._handlers or self._config.inbound.emit_raw_events:
+                self.schedule(self._handle_interaction_event(data))
+        except Exception as e:
+            logger.exception("cardAction schedule failed: %s", e)
+        return P2CardActionTriggerResponse({})
+
+    def _on_p2_reaction_created(self, data: Any) -> None:
+        self.schedule(self._handle_reaction_event(data, action="create"))
+
+    def _on_p2_reaction_deleted(self, data: Any) -> None:
+        self.schedule(self._handle_reaction_event(data, action="delete"))
+
+    def _on_p2_bot_added(self, data: Any) -> None:
+        self.schedule(self._handle_bot_event(data, joined=True))
+
+    def _on_p2_bot_deleted(self, data: Any) -> None:
+        self.schedule(self._handle_bot_event(data, joined=False))
+
+    def _on_p2_message_read(self, data: Any) -> None:
+        self.schedule(self._handle_message_read_event(data))
+
+    def _on_p1_comment_add(self, data: Any) -> None:
+        self.schedule(self._handle_comment_event(data))
+
+    # ------------------------------------------------------------------
+    # Async event handlers
+    # ------------------------------------------------------------------
+    async def _emit_raw_event(self, data: Any) -> None:
+        if not self._config.inbound.emit_raw_events:
+            return
+        await self._invoke("raw", _coerce.obj_to_dict(data) or {})
+
+    async def _handle_message_event(self, data: Any) -> None:
+        try:
+            await self._emit_raw_event(data)
+            event = getattr(data, "event", None)
+            header = getattr(data, "header", None)
+            event_id = getattr(header, "event_id", None)
+            message = getattr(event, "message", None)
+            sender = getattr(event, "sender", None)
+            if message is None:
+                return
+            inbound = await self._pipeline.process(
+                event_id=event_id,
+                message_event=message,
+                sender=sender,
+            )
+            if inbound is None:
+                return
+            if self._safety is not None:
+                await self._safety.push_message(inbound)
+            else:
+                await self._dispatch_inbound_to_user(inbound)
+        except Exception as e:
+            logger.exception("FeishuChannel.handle_message_event failed: %s", e)
+
+    async def _dispatch_inbound_to_user(self, inbound) -> None:
+        await self._invoke("message", inbound)
+
+    def _emit_reject(self, event: RejectEvent) -> None:
+        handlers = self._handlers.get("reject")
+        if not handlers:
+            logger.debug(
+                "policy reject message=%s reason=%s", event.message_id, event.reason
+            )
+            return
+        for handler in list(handlers):
+            try:
+                result = handler(event)
+                if inspect.isawaitable(result):
+                    self.schedule(result)
+            except Exception as e:  # pragma: no cover
+                logger.warning("FeishuChannel.on('reject') raised: %s", e)
+
+    async def _handle_interaction_event(self, data: P2CardActionTrigger) -> None:
+        try:
+            await self._emit_raw_event(data)
+            event = getattr(data, "event", None)
+            action = getattr(event, "action", None)
+            raw_value = getattr(action, "value", None)
+            if isinstance(raw_value, str):
+                try:
+                    parsed = json.loads(raw_value)
+                    raw_value = parsed if isinstance(parsed, dict) else {"value": parsed}
+                except ValueError:
+                    raw_value = {"value": raw_value}
+            tag = getattr(action, "tag", None)
+            context = getattr(event, "context", None)
+            message_id = getattr(context, "open_message_id", None)
+            chat_id = getattr(context, "open_chat_id", None)
+            operator_open_id = getattr(
+                getattr(event, "operator", None), "open_id", None
+            )
+            payload = CardActionEvent(
+                message_id=message_id or "",
+                chat_id=chat_id or "",
+                operator=EventOperator(open_id=operator_open_id or ""),
+                action=CardActionPayload(
+                    tag=tag or "",
+                    value=raw_value,
+                    name=getattr(raw_value, "name", None)
+                    if hasattr(raw_value, "name")
+                    else None,
+                    form_value=getattr(action, "form_value", None),
+                    input_value=getattr(action, "input_value", None),
+                    options=getattr(action, "options", None),
+                    checked=getattr(action, "checked", None),
+                ),
+                raw=_coerce.obj_to_dict(data) or {},
+            )
+            # Route through safety.push_action (tier 2): dedup on a stable
+            # action identity (tag + value payload) so Feishu's at-least-once
+            # WS redelivery can't double-invoke the handler, and serialize by
+            # chat_id so two fast clicks in the same chat are processed in
+            # order.
+            await self._through_action_safety(
+                event_id=f"card:{payload.message_id}:{payload.operator.open_id}:"
+                         f"{_card_action_identity(payload.action)}",
+                queue_scope=payload.chat_id or payload.message_id or "",
+                handler=lambda: self._invoke("cardAction", payload),
+            )
+        except Exception as e:
+            logger.exception("FeishuChannel cardAction dispatch failed: %s", e)
+
+    async def _through_action_safety(
+        self,
+        *,
+        event_id: str,
+        queue_scope: str,
+        handler: Callable[[], Any],
+    ) -> None:
+        """Run ``handler`` through the safety tier-2 gate (dedup + lock +
+        per-scope serial queue) when the pipeline exists; fall back to a
+        direct invocation when it hasn't been built yet (early events during
+        startup, unit tests that bypass ``connect``)."""
+        safety = self._safety
+        if safety is None:
+            result = handler()
+            if inspect.isawaitable(result):
+                await result
+            return
+
+        async def _run() -> None:
+            result = handler()
+            if inspect.isawaitable(result):
+                await result
+
+        await safety.push_action(event_id, queue_scope or event_id, _run)
+
+    async def _through_light_safety(
+        self,
+        *,
+        event_id: str,
+        handler: Callable[[], Any],
+    ) -> None:
+        """Tier-3 variant: dedup only (reaction add/remove). Same fallback
+        semantics as :meth:`_through_action_safety`."""
+        safety = self._safety
+        if safety is None:
+            result = handler()
+            if inspect.isawaitable(result):
+                await result
+            return
+
+        async def _run() -> None:
+            result = handler()
+            if inspect.isawaitable(result):
+                await result
+
+        await safety.push_light(event_id, _run)
+
+    async def _handle_reaction_event(self, data: Any, *, action: str) -> None:
+        await self._emit_raw_event(data)
+        cfg = self._config.inbound.reaction_notifications
+        if cfg == "off":
+            return
+        try:
+            event = getattr(data, "event", None) or {}
+            user = getattr(event, "user_id", None)
+            message_id = getattr(event, "message_id", None) or ""
+            operator_open_id = (
+                getattr(user, "open_id", None) if user is not None else None
+            )
+            emoji_type = getattr(
+                getattr(event, "reaction_type", None), "emoji_type", None
+            )
+            action_time = getattr(event, "action_time", None)
+            raw_dict = _coerce.obj_to_dict(data) or {}
+            raw_event = raw_dict.get("event") if isinstance(raw_dict, dict) else {}
+            if not isinstance(raw_event, dict):
+                raw_event = {}
+            chat_id = getattr(event, "chat_id", None) or raw_event.get("chat_id")
+            chat_type = getattr(event, "chat_type", None) or raw_event.get("chat_type")
+            context = self._sent_message_context.get(message_id)
+            if context is not None:
+                if not chat_id:
+                    chat_id = context.chat_id
+                if not chat_type:
+                    chat_type = context.chat_type
+
+            if cfg == "own":
+                if message_id and message_id not in self._sent_messages:
+                    return
+
+            direction = "added" if action == "create" else "removed"
+            payload = ReactionEvent(
+                message_id=message_id,
+                operator=EventOperator(open_id=operator_open_id or ""),
+                emoji_type=emoji_type or "",
+                action=direction,
+                chat_id=chat_id or None,
+                chat_type=chat_type or None,
+                action_time=action_time,
+                raw=raw_dict,
+            )
+            # Tier 3: dedup only. Reactions are idempotent state changes so
+            # lock / serial queue would add latency for no benefit, but
+            # WS redelivery would double-invoke without this guard.
+            # The light safety tier keeps that dedup-only behavior explicit.
+            await self._through_light_safety(
+                event_id=(
+                    f"reaction:{message_id}:{operator_open_id or ''}:"
+                    f"{emoji_type or ''}:{direction}"
+                ),
+                handler=lambda: self._invoke("reaction", payload),
+            )
+        except Exception as e:
+            logger.exception("FeishuChannel reaction dispatch failed: %s", e)
+
+    async def _handle_bot_event(self, data: Any, *, joined: bool) -> None:
+        try:
+            await self._emit_raw_event(data)
+            event = getattr(data, "event", None) or {}
+            chat_id = getattr(event, "chat_id", None) or ""
+            operator = getattr(event, "operator_id", None)
+            open_id = getattr(operator, "open_id", None) if operator else None
+            raw_dict = _coerce.obj_to_dict(data)
+            payload_cls = BotAddedEvent if joined else BotLeaveEvent
+            name = "botAdded" if joined else "botLeave"
+            await self._invoke(
+                name,
+                payload_cls(
+                    chat_id=chat_id,
+                    operator=EventOperator(open_id=open_id or ""),
+                    raw=raw_dict or {},
+                ),
+            )
+        except Exception as e:
+            logger.exception(
+                "FeishuChannel bot-%s dispatch failed: %s",
+                "added" if joined else "leave", e,
+            )
+
+    async def _handle_message_read_event(self, data: Any) -> None:
+        try:
+            await self._emit_raw_event(data)
+            event = getattr(data, "event", None) or {}
+            reader = getattr(event, "reader", None)
+            reader_open_id = getattr(reader, "reader_id", None) and getattr(
+                reader.reader_id, "open_id", None
+            )
+            message_ids = list(getattr(event, "message_id_list", []) or [])
+            await self._invoke(
+                "messageRead",
+                MessageReadEvent(
+                    reader=EventOperator(open_id=reader_open_id or ""),
+                    message_ids=message_ids,
+                    raw=_coerce.obj_to_dict(data) or {},
+                ),
+            )
+        except Exception as e:
+            logger.exception("FeishuChannel messageRead dispatch failed: %s", e)
+
+    async def _handle_comment_event(self, data: Any) -> None:
+        try:
+            await self._emit_raw_event(data)
+            # ``CustomizedEvent.event`` is the raw inner event payload as a
+            # plain dict; the per-event timestamp lives on the envelope
+            # (``header.create_time`` for p2, ``ts`` for p1) — not in the
+            # inner dict — so pass it explicitly.
+            raw_event = getattr(data, "event", None)
+            header = getattr(data, "header", None)
+            envelope_ts = (
+                getattr(header, "create_time", None) if header is not None
+                else getattr(data, "ts", None)
+            )
+            normalized = normalize_comment(
+                raw_event if raw_event is not None else data,
+                bot_open_id=self._bot_open_id,
+                envelope_timestamp=envelope_ts,
+            )
+            if normalized is None:
+                return
+            # Tier 2: dedup + lock + per-file_token serial queue. Multiple
+            # comments on the same document are ordered; redeliveries of the
+            # same comment event are dropped.
+            await self._through_action_safety(
+                event_id=f"comment:{normalized.file_token}:{normalized.comment_id}",
+                queue_scope=normalized.file_token,
+                handler=lambda: self._invoke("comment", normalized),
+            )
+        except Exception as e:
+            logger.exception("FeishuChannel comment dispatch failed: %s", e)
+
+    def _notify_reconnecting(self) -> None:
+        self._connection_state = "reconnecting"
+        self._connection_reconnect_attempts += 1
+        for h in list(self._handlers.get("reconnecting", [])):
+            try:
+                h()
+            except Exception as e:  # pragma: no cover
+                logger.warning("reconnecting handler raised: %s", e)
+
+    def _notify_reconnected(self) -> None:
+        self._connection_state = "connected"
+        self._connection_last_connected_at = time.time()
+        for h in list(self._handlers.get("reconnected", [])):
+            try:
+                h()
+            except Exception as e:  # pragma: no cover
+                logger.warning("reconnected handler raised: %s", e)
+
+    def _record_connection_error(self, error: BaseException) -> None:
+        self._connection_state = "error"
+        self._connection_last_error_at = time.time()
+        self._connection_last_error = str(error)
+
+    def connection_snapshot(self) -> ConnectionSnapshot:
+        return ConnectionSnapshot(
+            state=self._connection_state,
+            ready=self._ready_flag,
+            reconnect_attempts=self._connection_reconnect_attempts,
+            last_connected_at=self._connection_last_connected_at,
+            last_disconnected_at=self._connection_last_disconnected_at,
+            last_error_at=self._connection_last_error_at,
+            last_error=self._connection_last_error,
+        )
+
+    # ------------------------------------------------------------------
+    # Outbound: send / stream / message ops
+    # ------------------------------------------------------------------
+    async def upload_media(
+        self,
+        source: MediaSource,
+        *,
+        kind: Literal["image", "file"],
+        file_name: Optional[str] = None,
+        file_type: Optional[str] = None,
+    ) -> str:
+        """Upload a media resource and return its Feishu ``image_key`` /
+        ``file_key`` without sending a message.
+
+        Public wrapper over the internal :func:`resolve_media_key` helper —
+        intended for callers that need to construct custom post AST (e.g.
+        ``audio + caption`` / ``file + caption``, which Feishu does not render
+        natively but accepts as ``msg_type=post`` with ``tag:audio|file``
+        nodes), or want to pre-upload + cache a key for cross-chat reuse.
+
+        ``source`` must be a :class:`MediaSource`; pass an explicit kind:
+
+        - ``MediaSource(kind="buffer", buffer=...)`` — in-memory bytes
+        - ``MediaSource(kind="file", path=...)`` — local file
+        - ``MediaSource(kind="url", url=...)`` — remote URL (SSRF-checked
+          against ``OutboundConfig.ssrf_allowlist``)
+        - ``MediaSource(kind="key", key=...)`` — pre-uploaded key (returned
+          unchanged; no upload performed)
+
+        ``kind`` selects the upload route: ``"image"`` → image upload (returns
+        ``image_key``), ``"file"`` → file upload (returns ``file_key``). For
+        audio / video, use ``kind="file"`` with ``file_type="opus"`` /
+        ``"mp4"`` — Feishu treats them as typed file uploads at the wire
+        level. ``file_name`` is shown in Feishu UI for ``kind="file"``.
+
+        Failures raise :class:`FeishuChannelError`:
+
+        - ``UPLOAD_FAILED`` — server rejection, network error, missing local
+          file, malformed response, or empty ``MediaSource(kind="key", key="")``
+        - ``SSRF_BLOCKED`` — URL source without an allowlist match
+
+        SSRF allowlist is taken from ``self.config.outbound.ssrf_allowlist``
+        — callers do **not** mutate the source object.
+        """
+        if not isinstance(source, MediaSource):
+            raise TypeError(
+                f"upload_media: source must be a MediaSource; "
+                f"got {type(source).__name__}"
+            )
+        if kind not in ("image", "file"):
+            raise ValueError(
+                f"upload_media: kind must be 'image' or 'file'; got {kind!r}"
+            )
+
+        from .outbound.media.uploader import resolve_media_key
+
+        key = await resolve_media_key(
+            self._sender._driver,
+            source,
+            kind,
+            file_name=file_name,
+            file_type=file_type,
+            ssrf_allowlist=self._config.outbound.ssrf_allowlist,
+        )
+        if key is None:
+            # ``resolve_media_key`` returns None only for "nothing to upload"
+            # inputs (kind="key" with empty key, or unhandled source shape).
+            # The public method commits to ``str`` — convert to UPLOAD_FAILED
+            # so callers don't need to handle Optional.
+            raise FeishuChannelError(
+                FeishuChannelErrorCode.UPLOAD_FAILED,
+                f"upload_media: source has no uploadable content "
+                f"(source.kind={source.kind!r})",
+                context={"source_kind": source.kind},
+            )
+        return key
+
+    async def send(self, to, message, opts=None) -> SendResult:
+        """Send a message to a chat / user / email.
+
+        ``message`` may be a dict (``{"text": "..."}``, ``{"markdown": "..."}``,
+        ``{"image": {...}}``, …), a typed :class:`OutboundMessage` dataclass,
+        or a bare string (shorthand for markdown). See :mod:`._coerce` for the
+        full accepted shape.
+
+        Errors: both raised exceptions (coercion errors, transport failures)
+        AND ``SendResult.fail(...)`` outcomes are also forwarded to any
+        handler registered via ``channel.on("error", ...)``, so apps can
+        centralise failure observation. The error is still returned /
+        raised to the immediate caller as well — forwarding does not swallow.
+        """
+        try:
+            outbound = _coerce.coerce_outbound(message)
+            send_opts = _coerce.coerce_send_opts(opts)
+            rit = send_opts.receive_id_type or infer_receive_id_type(to)
+            result = await self._sender.send(
+                outbound,
+                receive_id=to,
+                receive_id_type=rit,
+                reply_to=send_opts.reply_to,
+                reply_in_thread=send_opts.reply_in_thread,
+                reply_target_gone=send_opts.reply_target_gone,
+                uuid_=send_opts.uuid,
+            )
+        except Exception as e:
+            await self._forward_outbound_error(e)
+            raise
+        if not result.success and result.error is not None:
+            await self._forward_outbound_error(result.error)
+        if result.success:
+            self._remember_sent_message_context(
+                result,
+                chat_id=to if rit == "chat_id" and isinstance(to, str) else None,
+                receive_id_type=rit,
+            )
+        return result
+
+    async def _forward_outbound_error(self, err: Any) -> None:
+        """Fan-out a send/stream failure to any ``on("error", ...)`` handlers.
+
+        :class:`SendError` is a dataclass without ``__traceback__`` or a
+        ``str``-friendly form, so generic diagnostic plumbing
+        (``logger.exception``, Sentry) chokes on it. Wrap it in
+        :class:`OutboundSendError` before dispatching. The wrapping does not
+        affect the value returned by ``channel.send()`` (still
+        :class:`SendResult`).
+
+        Never swallows — the error still propagates to the direct caller.
+        Handler exceptions are logged but otherwise ignored.
+        """
+        if isinstance(err, SendError):
+            err = OutboundSendError(err)
+        for h in list(self._handlers.get("error", [])):
+            try:
+                result = h(err)
+                if inspect.isawaitable(result):
+                    await result
+            except Exception as inner:  # pragma: no cover - defensive
+                logger.warning("on('error') handler raised: %s", inner)
+
+    async def stream(self, to, spec: Dict[str, Any], opts=None) -> SendResult:
+        """Stream a message progressively.
+
+        ``spec`` is either ``{"markdown": producer}`` or
+        ``{"card": {"initial": ..., "producer": ...}}``.
+
+        Errors (coercion + stream controller raises) are also forwarded to
+        any ``on("error", ...)`` handlers before being re-raised to the
+        caller, same contract as :meth:`send`.
+        """
+        try:
+            if not isinstance(spec, dict):
+                raise TypeError("stream spec must be a dict")
+            send_opts = _coerce.coerce_send_opts(opts)
+            rit = send_opts.receive_id_type or infer_receive_id_type(to)
+        except Exception as e:
+            await self._forward_outbound_error(e)
+            raise
+
+        if "markdown" in spec:
+            # Markdown streaming uses the CardKit preallocation flow — every
+            # throttle tick is an `update_card_element_content` call (seq-ordered
+            # element patch) instead of a full-card PATCH. See
+            # :mod:`.outbound.streaming.markdown_stream` for the protocol.
+            ctl = MarkdownStreamController(
+                to=to,
+                receive_id_type=rit,
+                reply_to=send_opts.reply_to,
+                reply_in_thread=send_opts.reply_in_thread,
+                reply_target_gone=send_opts.reply_target_gone,
+                create_card_instance=self.create_card_instance,
+                send_card_by_reference=self.send_card_by_reference,
+                update_card_element_content=self.update_card_element_content,
+                finish_streaming_card=self.finish_streaming_card,
+            )
+            try:
+                mid = await ctl.run(spec["markdown"])
+            except Exception as e:
+                await self._forward_outbound_error(e)
+                raise
+            return SendResult.ok(message_id=mid)
+
+        if "card" in spec:
+            card_def = spec["card"]
+            initial = card_def.get("initial") if isinstance(card_def, dict) else None
+            producer = card_def.get("producer") if isinstance(card_def, dict) else None
+            if initial is None or not callable(producer):
+                err = TypeError("card stream requires {initial, producer}")
+                await self._forward_outbound_error(err)
+                raise err
+            ctl = CardStreamController(
+                initial=initial,
+                ensure_created=lambda snap: self._ensure_card_snapshot(
+                    to, rit, snapshot=snap,
+                    reply_to=send_opts.reply_to,
+                    reply_in_thread=send_opts.reply_in_thread,
+                    reply_target_gone=send_opts.reply_target_gone,
+                ),
+                patch_card=self._patch_card,
+            )
+            try:
+                mid = await ctl.run(producer)
+            except Exception as e:
+                await self._forward_outbound_error(e)
+                raise
+            return SendResult.ok(message_id=mid)
+
+        err = TypeError("stream spec must contain 'markdown' or 'card'")
+        await self._forward_outbound_error(err)
+        raise err
+
+    async def update_card(self, message_id: str, card: Dict[str, Any]) -> SendResult:
+        """Update a card message. Returns a :class:`SendResult`."""
+        raw = await self._patch_card(message_id, card)
+        return _coerce.result_from_raw(raw, message_id=message_id)
+
+    async def recall_message(self, message_id: str) -> SendResult:
+        raw = await self._driver.delete_message(message_id=message_id)
+        return _coerce.result_from_raw(raw, message_id=message_id)
+
+    async def add_reaction(self, message_id: str, emoji_type: str) -> SendResult:
+        raw = await self._driver.add_reaction(
+            message_id=message_id, emoji_type=emoji_type
+        )
+        return _coerce.result_from_raw(raw, message_id=message_id)
+
+    async def remove_reaction(self, message_id: str, reaction_id: str) -> SendResult:
+        raw = await self._driver.remove_reaction(
+            message_id=message_id, reaction_id=reaction_id
+        )
+        return _coerce.result_from_raw(raw, message_id=message_id)
+
+    async def list_reactions(
+        self,
+        message_id: str,
+        emoji_type: Optional[str] = None,
+        *,
+        page_token: Optional[str] = None,
+        page_size: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        return await self._driver.list_reactions(
+            message_id=message_id,
+            emoji_type=emoji_type,
+            page_token=page_token,
+            page_size=page_size,
+        )
+
+    async def remove_reaction_by_emoji(
+        self,
+        message_id: str,
+        emoji_type: str,
+    ) -> SendResult:
+        raw = await self._driver.list_reactions(
+            message_id=message_id,
+            emoji_type=emoji_type,
+            page_token=None,
+            page_size=None,
+        )
+        data = (raw or {}).get("data") if isinstance(raw, dict) else None
+        items = data.get("items") if isinstance(data, dict) else None
+        for item in items if isinstance(items, list) else []:
+            reaction = item.get("reaction_type") if isinstance(item, dict) else None
+            if not isinstance(reaction, dict) or reaction.get("emoji_type") != emoji_type:
+                continue
+            reaction_id = item.get("reaction_id")
+            if reaction_id:
+                return await self.remove_reaction(message_id, reaction_id)
+        return SendResult.fail(
+            SendError(
+                code=FeishuChannelErrorCode.UNKNOWN,
+                retryable=False,
+                hint=f"reaction not found for emoji_type={emoji_type}",
+            ),
+            raw=raw if isinstance(raw, dict) else None,
+        )
+
+    async def add_typing_reaction(self, message_id: str) -> Optional[str]:
+        try:
+            result = await self.add_reaction(message_id, "Typing")
+            raw = getattr(result, "raw", None)
+            if raw is None and isinstance(result, dict):
+                raw = result
+            data = (raw or {}).get("data") or {}
+            return data.get("reaction_id")
+        except Exception:
+            return None
+
+    async def remove_typing_reaction(self, message_id: str, reaction_id: str) -> bool:
+        try:
+            result = await self.remove_reaction(message_id, reaction_id)
+            return bool(getattr(result, "success", False))
+        except Exception:
+            return False
+
+    def _comment_client(self) -> CommentPrimitiveClient:
+        return CommentPrimitiveClient(raw_request=lambda req: self._client.arequest(req))
+
+    async def resolve_comment_target(
+        self,
+        *,
+        file_token: str,
+        file_type: str,
+    ) -> CommentTarget:
+        return await self._comment_client().resolve_comment_target(
+            file_token=file_token,
+            file_type=file_type,
+        )
+
+    async def get_comment_context(
+        self,
+        *,
+        target: CommentTarget,
+        comment_id: str,
+        event_reply_id: Optional[str] = None,
+    ) -> CommentContext:
+        return await self._comment_client().get_comment_context(
+            target=target,
+            comment_id=comment_id,
+            event_reply_id=event_reply_id,
+        )
+
+    async def fetch_comment(
+        self,
+        *,
+        target: CommentTarget,
+        comment_id: str,
+    ):
+        return await self._comment_client().fetch_comment(
+            target=target,
+            comment_id=comment_id,
+        )
+
+    async def list_comments(
+        self,
+        *,
+        target: CommentTarget,
+        page_token=None,
+        page_size=None,
+        is_whole=None,
+        is_solved=None,
+    ):
+        return await self._comment_client().list_comments(
+            target=target,
+            page_token=page_token,
+            page_size=page_size,
+            is_whole=is_whole,
+            is_solved=is_solved,
+        )
+
+    async def list_comment_replies(
+        self,
+        *,
+        target: CommentTarget,
+        comment_id: str,
+        page_token=None,
+        page_size=None,
+    ):
+        return await self._comment_client().list_comment_replies(
+            target=target,
+            comment_id=comment_id,
+            page_token=page_token,
+            page_size=page_size,
+        )
+
+    async def reply_comment(self, context: CommentContext, content: str):
+        return await self._comment_client().reply_comment(context, content)
+
+    async def edit_message(self, message_id: str, message) -> SendResult:
+        """Edit a previously sent text or post message.
+
+        Accepted message shapes mirror send() for editable types: str,
+        {"markdown": ...}, {"text": ...}, {"post": ...}, OutboundText,
+        and OutboundPost. Cards must use update_card(); media/share/sticker
+        messages are not editable through this method.
+        """
+        outbound = _coerce.coerce_outbound(message)
+        if isinstance(outbound, OutboundCard):
+            raise TypeError("edit_message does not support cards; use update_card()")
+        if not isinstance(outbound, (OutboundText, OutboundPost)):
+            raise TypeError(
+                "edit_message only supports text/post messages; "
+                f"got {type(outbound).__name__}"
+            )
+        body = await self._sender.materialize_for_edit(outbound)
+        raw = await self._driver.update_message(
+            message_id=message_id,
+            msg_type=body["msg_type"],
+            content=body["content"],
+        )
+        return _coerce.result_from_raw(raw, message_id=message_id)
+
+    async def download_resource(
+        self,
+        file_key: str,
+        resource_type: str = "image",
+        message_id: Optional[str] = None,
+    ) -> Optional[bytes]:
+        return await self._download_media(
+            message_id=message_id or "",
+            file_key=file_key,
+            resource_type=resource_type,
+        )
+
+    async def _download_media(
+        self, *, message_id: str, file_key: str, resource_type: str
+    ) -> Optional[bytes]:
+        return await _api_helpers.download_media(
+            self._client,
+            message_id=message_id,
+            file_key=file_key,
+            resource_type=resource_type,
+        )
+
+    async def download_resource_to_file(
+        self,
+        file_key: str,
+        *,
+        resource_type: str = "image",
+        message_id: Optional[str] = None,
+        dest_dir: "Path",
+        file_name: Optional[str] = None,
+    ) -> "Path":
+        """Download a resource to disk and return the absolute path.
+
+        Args:
+            file_key: opaque resource identifier from the inbound event.
+            resource_type: ``image`` / ``file`` / ``audio`` / ``video``.
+            message_id: when supplied, downloads via the message-resource
+                endpoint; without it, falls back to the standalone
+                image/file endpoints.
+            dest_dir: target directory (auto-created if missing).
+            file_name: override the auto-generated filename. When None, the
+                file is named ``<file_key><suffix>`` where ``<suffix>`` is
+                inferred from the response's content-type / file_name.
+
+        Returns:
+            Absolute path to the downloaded file.
+
+        Raises:
+            FeishuChannelError(DOWNLOAD_FAILED): when the download fails or
+                the response has no body.
+        """
+        from pathlib import Path
+        import os
+        import tempfile
+
+        body, meta = await _api_helpers.download_media_with_meta(
+            self._client,
+            message_id=message_id or "",
+            file_key=file_key,
+            resource_type=resource_type,
+        )
+        if body is None:
+            raise FeishuChannelError(
+                FeishuChannelErrorCode.DOWNLOAD_FAILED,
+                f"download failed: file_key={file_key} resource_type={resource_type}",
+            )
+
+        dest_dir = Path(dest_dir)
+        dest_dir.mkdir(parents=True, exist_ok=True)
+
+        if file_name:
+            name = file_name
+        else:
+            suffix = self._infer_suffix(meta, resource_type)
+            name = f"{file_key}{suffix}"
+        name = self._safe_download_file_name(name)
+        out = dest_dir / name
+
+        # Atomic: write to tmp file in same dir, then rename.
+        fd, tmp_path = tempfile.mkstemp(prefix=".dl-", dir=str(dest_dir))
+        try:
+            with os.fdopen(fd, "wb") as fh:
+                fh.write(body)
+            os.replace(tmp_path, out)
+        except Exception:
+            try:
+                os.unlink(tmp_path)
+            except OSError:
+                pass
+            raise
+        return out
+
+    async def resolve_resource_to_cache(
+        self,
+        *,
+        message_id: str,
+        resource: ResourceDescriptor,
+    ) -> CachedResource:
+        return await self._media_cache.resolve(
+            message_id=message_id,
+            resource=resource,
+            downloader=lambda **kwargs: _api_helpers.download_media_with_meta(
+                self._client,
+                **kwargs,
+            ),
+        )
+
+    async def resolve_resources_to_cache(
+        self, *, message_id: str, resources: List[ResourceDescriptor]
+    ) -> List[CachedResource]:
+        return [
+            await self.resolve_resource_to_cache(message_id=message_id, resource=resource)
+            for resource in resources
+        ]
+
+    @staticmethod
+    def _safe_download_file_name(name: str) -> str:
+        """Validate a download filename before joining it under dest_dir."""
+        from pathlib import PureWindowsPath
+        import os
+
+        name = (name or "").replace("\x00", "")
+        win = PureWindowsPath(name)
+        if (
+            not name
+            or name in (".", "..")
+            or os.path.isabs(name)
+            or "/" in name
+            or "\\" in name
+            or win.drive
+            or win.root
+            or any(part in ("", ".", "..") for part in win.parts)
+        ):
+            raise FeishuChannelError(
+                FeishuChannelErrorCode.DOWNLOAD_FAILED,
+                f"unsafe download file name: {name!r}",
+            )
+        return name
+
+    @staticmethod
+    def _infer_suffix(meta: Optional[str], resource_type: str) -> str:
+        """Best-effort suffix derivation from content-type / filename.
+
+        Falls back to ``.bin`` when nothing is parseable, then to type-default
+        suffixes for the four common ``resource_type`` values.
+        """
+        import mimetypes
+
+        if meta:
+            # If meta looks like a filename (has a dot in last segment),
+            # return its suffix directly.
+            if "/" not in meta and "." in meta:
+                ext = "." + meta.rsplit(".", 1)[-1]
+                if 1 < len(ext) <= 6:
+                    return ext.lower()
+            # Otherwise treat as a MIME type
+            ext = mimetypes.guess_extension(meta.split(";", 1)[0].strip())
+            if ext:
+                return ext
+
+        return {
+            "image": ".jpg",
+            "audio": ".mp3",
+            "video": ".mp4",
+            "file": ".bin",
+        }.get(resource_type, ".bin")
+
+    async def get_chat_info(self, chat_id: str) -> Optional[ChatInfo]:
+        """Fetch chat metadata. Returns None on API failure."""
+        return await _api_helpers.fetch_chat_info(self._client, chat_id)
+
+    async def get_chat_mode(self, chat_id: str) -> Optional[str]:
+        cached = self._chat_mode_cache.get(chat_id)
+        if cached is not None:
+            return cached
+        info = await self.get_chat_info(chat_id)
+        mode = info.chat_mode if info is not None else None
+        if mode:
+            self._chat_mode_cache.set(chat_id, mode)
+            return mode
+        return self._config.chat_mode_cache.fallback
+
+    # ------------------------------------------------------------------
+    # CardKit preallocation API
+    # ------------------------------------------------------------------
+    async def create_card_instance(self, spec: Dict[str, Any]) -> str:
+        """Create a pre-allocated card via ``POST /open-apis/cardkit/v1/card``.
+
+        Returns the ``card_id`` string. Use with :meth:`send_card_by_reference`
+        / :meth:`update_card_element_content` / :meth:`finish_streaming_card`
+        for the CardKit typewriter-streaming flow.
+        """
+        raw = await self._driver.cardkit_create(
+            body={"type": "card_json", "data": json.dumps(spec, ensure_ascii=False)}
+        )
+        if not isinstance(raw, dict) or raw.get("code", 0) != 0:
+            raise FeishuChannelError(
+                FeishuChannelErrorCode.UNKNOWN,
+                f"create_card_instance failed: {raw}",
+            )
+        data = raw.get("data") or {}
+        card_id = data.get("card_id")
+        if not card_id:
+            raise FeishuChannelError(
+                FeishuChannelErrorCode.UNKNOWN,
+                f"create_card_instance response missing card_id: {raw}",
+            )
+        return str(card_id)
+
+    async def send_card_by_reference(
+        self,
+        to: str,
+        card_id: str,
+        *,
+        receive_id_type: Optional[str] = None,
+        reply_to: Optional[str] = None,
+        reply_in_thread: Optional[bool] = None,
+        reply_target_gone: str = "fresh",
+    ) -> SendResult:
+        """Send a message that references a pre-allocated card (see
+        :meth:`create_card_instance`)."""
+        rit = receive_id_type or infer_receive_id_type(to)
+        return await self._sender.send(
+            OutboundCard(card={"type": "card", "data": {"card_id": card_id}}),
+            receive_id=to,
+            receive_id_type=rit,
+            reply_to=reply_to,
+            reply_in_thread=reply_in_thread,
+            reply_target_gone=reply_target_gone,
+        )
+
+    async def update_card_element_content(
+        self,
+        card_id: str,
+        element_id: str,
+        content: str,
+        sequence: int,
+    ) -> None:
+        """Typewriter-update a card element. ``sequence`` must strictly increase."""
+        raw = await self._driver.cardkit_update_element(
+            card_id=card_id,
+            element_id=element_id,
+            body={"content": content, "sequence": sequence},
+        )
+        if isinstance(raw, dict) and raw.get("code", 0) != 0:
+            raise FeishuChannelError(
+                FeishuChannelErrorCode.UNKNOWN,
+                f"update_card_element_content failed: {raw}",
+            )
+
+    async def finish_streaming_card(self, card_id: str, sequence: int) -> None:
+        """Close ``streaming_mode`` on a pre-allocated card."""
+        settings = json.dumps(
+            {"config": {"streaming_mode": False}}, ensure_ascii=False
+        )
+        raw = await self._driver.cardkit_update_settings(
+            card_id=card_id,
+            body={"settings": settings, "sequence": sequence},
+        )
+        if isinstance(raw, dict) and raw.get("code", 0) != 0:
+            raise FeishuChannelError(
+                FeishuChannelErrorCode.UNKNOWN,
+                f"finish_streaming_card failed: {raw}",
+            )
+
+    # ------------------------------------------------------------------
+    # Card streaming internals
+    # ------------------------------------------------------------------
+    async def _ensure_card(
+        self,
+        to,
+        rit,
+        *,
+        initial_text,
+        reply_to,
+        reply_in_thread,
+        reply_target_gone="fresh",
+    ) -> str:
+        """Compatibility wrapper for older internal card-stream call sites."""
+        return await self._ensure_card_snapshot(
+            to, rit,
+            snapshot={
+                "schema": "2.0",
+                "config": {"streaming_mode": True, "summary": {"content": ""}},
+                "body": {"elements": [{"tag": "markdown", "content": initial_text or "..."}]},
+            },
+            reply_to=reply_to,
+            reply_in_thread=reply_in_thread,
+            reply_target_gone=reply_target_gone,
+        )
+
+    async def _ensure_card_snapshot(
+        self,
+        to,
+        rit,
+        *,
+        snapshot,
+        reply_to,
+        reply_in_thread,
+        reply_target_gone="fresh",
+    ) -> str:
+        result = await self._sender.send(
+            OutboundCard(card=snapshot),
+            receive_id=to,
+            receive_id_type=rit,
+            reply_to=reply_to,
+            reply_in_thread=reply_in_thread,
+            reply_target_gone=reply_target_gone,
+        )
+        if not result.success or not result.message_id:
+            code = result.error.code if result.error else FeishuChannelErrorCode.UNKNOWN
+            raise FeishuChannelError(
+                code, f"failed to create streaming card: {result.error}"
+            )
+        return result.message_id
+
+    async def _patch_card(self, message_id: str, card: Dict[str, Any]) -> Dict[str, Any]:
+        raw = await self._driver.patch_message(
+            message_id=message_id,
+            content=json.dumps(card, ensure_ascii=False),
+        )
+        code = (raw or {}).get("code", 0)
+        if code != 0:
+            logger.warning(
+                "channel.card_patch: patch failed code=%s msg=%s",
+                code, (raw or {}).get("msg"),
+            )
+        return raw
+
+    # ------------------------------------------------------------------
+    # Fetch payload
+    # ------------------------------------------------------------------
+    async def fetch_message(self, message_id: str) -> Dict[str, Any]:
+        """Fetch a message by ID and return the raw Feishu ``im.v1.message.get``
+        response as a dict.
+
+        This is a thin wrapper over the underlying OpenAPI call — no
+        normalization is performed. Use it for cases like "look up the text
+        of a message the user replied to" where you need ad-hoc access to
+        the wire payload. For the typed :class:`InboundMessage` shape, feed
+        events through the inbound pipeline normally.
+        """
+        return await self._driver.fetch_message(message_id)
+
+    async def fetch_inbound_message(self, message_id: str):
+        raw = await self._driver.fetch_message(message_id)
+        item = _extract_first_message_item(raw)
+        if item is None:
+            return None
+        sender = _extract_fetched_sender(item)
+        message = _normalize_fetched_message_item(item)
+        return await self._pipeline.normalize(message_event=message, sender=sender)
+
+    async def fetch_quoted_context(self, message_id: str):
+        resolver = QuoteResolver(
+            fetcher=lambda mid: _api_helpers.fetch_message_raw(
+                self._client,
+                mid,
+                card_content_type="user_card_content",
+            )
+        )
+        return await resolver.fetch_quoted_context(message_id)
+
+    async def resolve_quoted_contexts(self, messages, *, chat_mode=None):
+        resolver = QuoteResolver(
+            fetcher=lambda mid: _api_helpers.fetch_message_raw(
+                self._client,
+                mid,
+                card_content_type="user_card_content",
+            )
+        )
+        return await resolver.resolve_quoted_contexts(messages, chat_mode=chat_mode)
+
+    async def select_quote_targets(self, messages, *, chat_mode=None):
+        return await self.resolve_quoted_contexts(messages, chat_mode=chat_mode)
+
+    # Alias used by the internal pipeline (kept stable for dependency
+    # injection; external callers should prefer ``fetch_message``).
+    async def _fetch_message_payload(self, message_id: str) -> Dict[str, Any]:
+        return await self._driver.fetch_message(message_id)
+
+    # ------------------------------------------------------------------
+    # UAT (user access token) — exposed for callers that need it explicitly
+    # ------------------------------------------------------------------
+    async def require_user_auth(
+        self,
+        user_open_id: str,
+        scopes: list,
+        *,
+        prompt_context: Any = None,
+    ) -> UAT:
+        """Resolve a user access token for ``user_open_id``, running the
+        device flow if needed. ``prompt_context`` must expose
+        ``respond(card)`` if the user needs a prompt card (usually the
+        original interaction carrier)."""
+        return await require_user_auth(
+            device_flow=self._device_flow,
+            token_store=self._token_store,
+            uat_config=self._config.uat,
+            user_open_id=user_open_id,
+            scopes=scopes,
+            context=prompt_context,
+        )
+
+    def _track_sent_message(self, message_id: str) -> None:
+        if not message_id:
+            return
+        self._sent_messages[message_id] = time.time()
+        self._sent_messages.move_to_end(message_id)
+        while len(self._sent_messages) > self._sent_messages_max:
+            evicted, _ = self._sent_messages.popitem(last=False)
+            self._sent_message_context.pop(evicted, None)
+
+    def _remember_sent_message_context(
+        self,
+        result: SendResult,
+        *,
+        chat_id: Optional[str],
+        receive_id_type: Optional[str],
+    ) -> None:
+        message_ids = list(result.chunk_ids or [])
+        if result.message_id and result.message_id not in message_ids:
+            message_ids.insert(0, result.message_id)
+        for message_id in message_ids:
+            self._track_sent_message(message_id)
+            if not chat_id:
+                self._sent_message_context.pop(message_id, None)
+                continue
+            self._sent_message_context[message_id] = _SentMessageContext(
+                message_id=message_id,
+                chat_id=chat_id,
+                receive_id_type=receive_id_type,
+            )
+            self._sent_message_context.move_to_end(message_id)
diff --git a/lark_channel/channel/chat_mode.py b/lark_channel/channel/chat_mode.py
new file mode 100644
index 0000000..4caf827
--- /dev/null
+++ b/lark_channel/channel/chat_mode.py
@@ -0,0 +1,32 @@
+import time
+from collections import OrderedDict
+from typing import Optional
+
+from .config import ChatModeCacheConfig
+
+
+class ChatModeCache:
+    def __init__(self, config: ChatModeCacheConfig) -> None:
+        self._config = config
+        self._values = OrderedDict()
+
+    def get(self, chat_id: str) -> Optional[str]:
+        if not self._config.enabled:
+            return None
+        item = self._values.get(chat_id)
+        if item is None:
+            return None
+        value, expires_at = item
+        if expires_at < time.time():
+            self._values.pop(chat_id, None)
+            return None
+        self._values.move_to_end(chat_id)
+        return value
+
+    def set(self, chat_id: str, chat_mode: str) -> None:
+        if not self._config.enabled or self._config.max_size <= 0:
+            return
+        self._values[chat_id] = (chat_mode, time.time() + self._config.ttl_seconds)
+        self._values.move_to_end(chat_id)
+        while len(self._values) > self._config.max_size:
+            self._values.popitem(last=False)
diff --git a/lark_channel/channel/comment.py b/lark_channel/channel/comment.py
new file mode 100644
index 0000000..051d922
--- /dev/null
+++ b/lark_channel/channel/comment.py
@@ -0,0 +1,301 @@
+import json
+import inspect
+from typing import Any, Callable, Dict, Optional
+
+from lark_channel.api.drive.comment import (
+    build_comment_create_request,
+    build_comment_get_request,
+    build_comment_list_request,
+    build_comment_reply_list_request,
+    build_comment_reply_update_request,
+)
+from lark_channel.api.wiki.node import build_wiki_node_get_request
+
+from .types import CommentContext, CommentTarget
+
+
+SUPPORTED_FILE_TYPES = {"doc", "docx", "sheet", "file"}
+
+
+class CommentPrimitiveClient:
+    def __init__(self, *, raw_request: Callable[[Any], Any]) -> None:
+        self._raw_request = raw_request
+
+    def resolve_comment_target_sync(
+        self,
+        *,
+        file_token: str,
+        file_type: str,
+    ) -> CommentTarget:
+        if file_type in SUPPORTED_FILE_TYPES:
+            return CommentTarget(
+                file_token=file_token,
+                file_type=file_type,
+                supported=True,
+            )
+        if file_type == "wiki":
+            return CommentTarget(
+                file_token=file_token,
+                file_type=file_type,
+                supported=True,
+                reason="wiki_requires_async_resolution",
+            )
+        return CommentTarget(
+            file_token=file_token,
+            file_type=file_type,
+            supported=False,
+            reason="unsupported_file_type",
+        )
+
+    async def resolve_comment_target(
+        self,
+        *,
+        file_token: str,
+        file_type: str,
+    ) -> CommentTarget:
+        direct = self.resolve_comment_target_sync(
+            file_token=file_token,
+            file_type=file_type,
+        )
+        if file_type != "wiki":
+            return direct
+
+        raw = await self._call(build_wiki_node_get_request(token=file_token))
+        data = (raw or {}).get("data") or {}
+        node = data.get("node") or data
+        obj_token = node.get("obj_token")
+        obj_type = node.get("obj_type")
+        if obj_token and obj_type in SUPPORTED_FILE_TYPES:
+            return CommentTarget(
+                file_token=obj_token,
+                file_type=obj_type,
+                supported=True,
+                raw=node,
+            )
+        return CommentTarget(
+            file_token=file_token,
+            file_type=file_type,
+            supported=False,
+            reason="wiki_resolution_failed",
+            raw=node if isinstance(node, dict) else {},
+        )
+
+    async def get_comment_context(
+        self,
+        *,
+        target: CommentTarget,
+        comment_id: str,
+        event_reply_id: Optional[str] = None,
+    ) -> CommentContext:
+        if not target.supported:
+            return CommentContext(target, comment_id, "", "", False, None)
+
+        raw = await self._call(
+            build_comment_get_request(
+                file_token=target.file_token,
+                file_type=target.file_type,
+                comment_id=comment_id,
+            )
+        )
+        if not raw or raw.get("code") != 0:
+            raw = await self._call(
+                build_comment_list_request(
+                    file_token=target.file_token,
+                    file_type=target.file_type,
+                )
+            )
+
+        data = (raw or {}).get("data") or {}
+        comment = _select_comment(data, comment_id)
+        replies = _comment_replies(comment)
+        target_reply_id = _select_reply_id(replies, event_reply_id)
+        return CommentContext(
+            target=target,
+            comment_id=comment_id,
+            question=_content_to_text(comment.get("content")),
+            quote=_content_to_text(comment.get("quote")),
+            is_whole=bool(comment.get("is_whole")),
+            target_reply_id=target_reply_id,
+            raw=comment,
+        )
+
+    async def fetch_comment(
+        self,
+        *,
+        target: CommentTarget,
+        comment_id: str,
+    ):
+        if not target.supported:
+            return None
+        return await self._call(
+            build_comment_get_request(
+                file_token=target.file_token,
+                file_type=target.file_type,
+                comment_id=comment_id,
+            )
+        )
+
+    async def list_comments(
+        self,
+        *,
+        target: CommentTarget,
+        page_token=None,
+        page_size=None,
+        is_whole=None,
+        is_solved=None,
+    ):
+        if not target.supported:
+            return None
+        return await self._call(
+            build_comment_list_request(
+                file_token=target.file_token,
+                file_type=target.file_type,
+                page_token=page_token,
+                page_size=page_size,
+                is_whole=is_whole,
+                is_solved=is_solved,
+            )
+        )
+
+    async def list_comment_replies(
+        self,
+        *,
+        target: CommentTarget,
+        comment_id: str,
+        page_token=None,
+        page_size=None,
+    ):
+        if not target.supported:
+            return None
+        return await self._call(
+            build_comment_reply_list_request(
+                file_token=target.file_token,
+                file_type=target.file_type,
+                comment_id=comment_id,
+                page_token=page_token,
+                page_size=page_size,
+            )
+        )
+
+    async def reply_comment(self, context: CommentContext, content: str):
+        if context.is_whole:
+            return await self._call(
+                build_comment_create_request(
+                    file_token=context.target.file_token,
+                    file_type=context.target.file_type,
+                    content=content,
+                )
+            )
+        if not context.target_reply_id:
+            return None
+        return await self._call(
+            build_comment_reply_update_request(
+                file_token=context.target.file_token,
+                file_type=context.target.file_type,
+                comment_id=context.comment_id,
+                reply_id=context.target_reply_id,
+                content=content,
+            )
+        )
+
+    async def _call(self, req):
+        result = self._raw_request(req)
+        if inspect.isawaitable(result):
+            result = await result
+        return _response_to_dict(result)
+
+
+def _select_reply_id(replies, event_reply_id):
+    if event_reply_id:
+        for reply in replies:
+            if reply.get("reply_id") == event_reply_id:
+                return event_reply_id
+        return None
+    if replies:
+        return replies[-1].get("reply_id")
+    return None
+
+
+def _comment_replies(comment: Dict[str, Any]):
+    reply_list = comment.get("reply_list")
+    if isinstance(reply_list, dict):
+        replies = reply_list.get("replies")
+        if isinstance(replies, list):
+            return replies
+    replies = comment.get("replies")
+    return replies if isinstance(replies, list) else []
+
+
+def _select_comment(data: Dict[str, Any], comment_id: str) -> Dict[str, Any]:
+    comment = data.get("comment")
+    if isinstance(comment, dict):
+        return comment
+    items = data.get("items") or data.get("comments") or []
+    for item in items:
+        if item.get("comment_id") == comment_id:
+            return item
+    return data
+
+
+def _response_to_dict(result: Any) -> Optional[Dict[str, Any]]:
+    if result is None:
+        return None
+    if isinstance(result, dict):
+        return _object_to_dict(result)
+    raw = getattr(result, "raw", None)
+    content = getattr(raw, "content", None)
+    if content:
+        if isinstance(content, bytes):
+            content = content.decode("utf-8")
+        if isinstance(content, str):
+            try:
+                parsed = json.loads(content)
+            except ValueError:
+                parsed = None
+            if isinstance(parsed, dict):
+                return _object_to_dict(parsed)
+    data = getattr(result, "data", None)
+    return {
+        "code": getattr(result, "code", 0),
+        "data": _object_to_dict(data),
+    }
+
+
+def _content_to_text(value: Any) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, str):
+        return value
+    if isinstance(value, list):
+        return "".join(_content_to_text(item) for item in value)
+    if not isinstance(value, dict):
+        return str(value)
+
+    text_run = value.get("text_run")
+    if isinstance(text_run, dict) and isinstance(text_run.get("text"), str):
+        return text_run["text"]
+    if isinstance(value.get("text"), str):
+        return value["text"]
+    if isinstance(value.get("content"), str):
+        return value["content"]
+
+    parts = []
+    for key in ("elements", "content", "children"):
+        nested = value.get(key)
+        if nested is not None:
+            parts.append(_content_to_text(nested))
+    return "".join(parts)
+
+
+def _object_to_dict(value: Any) -> Any:
+    if isinstance(value, dict):
+        return {key: _object_to_dict(val) for key, val in value.items()}
+    if isinstance(value, list):
+        return [_object_to_dict(item) for item in value]
+    if hasattr(value, "__dict__"):
+        return {
+            key: _object_to_dict(val)
+            for key, val in value.__dict__.items()
+            if not key.startswith("_")
+        }
+    return value
diff --git a/lark_channel/channel/config.py b/lark_channel/channel/config.py
new file mode 100644
index 0000000..4d799e7
--- /dev/null
+++ b/lark_channel/channel/config.py
@@ -0,0 +1,497 @@
+"""Configuration for :class:`FeishuChannel`.
+
+**One schema**: ``policy`` / ``safety`` / ``inbound`` / ``outbound`` / ``uat``
+live at the top level of :class:`ChannelConfig`. Names follow Python
+conventions — ``snake_case`` throughout and explicit time-unit suffixes
+(``ttl_seconds``, ``delay_ms``, …). What you configure is what consumers read.
+
+Typical construction::
+
+    channel = FeishuChannel(app_id="cli_xxx", app_secret="***")
+
+    channel = FeishuChannel(
+        app_id="cli_xxx",
+        app_secret="***",
+        safety=SafetyConfig(
+            dedup=DedupConfig(ttl_seconds=12 * 3600, max_entries=10_000),
+            text_batch=TextBatchConfig(delay_ms=800),
+        ),
+        outbound=OutboundConfig(
+            text_chunk_limit=2000,
+            retry=RetryConfig(max_attempts=5, base_delay_ms=250),
+            ssrf_allowlist=["cdn.example.com"],
+        ),
+    )
+"""
+
+from dataclasses import dataclass, field
+from typing import Any, Awaitable, Callable, Dict, List, Literal, Optional, Union
+
+from lark_channel.core.const import FEISHU_DOMAIN
+from lark_channel.core.enum import LogLevel
+
+
+# ---------------------------------------------------------------------------
+# Safety-layer primitives
+# ---------------------------------------------------------------------------
+# These used to live in safety/types.py, but the safety package eagerly
+# imports SafetyPipeline which needs PolicyConfig from this module — a
+# circular import. Defining them here breaks the cycle; the safety package
+# imports them from here.
+
+
+@dataclass
+class DedupConfig:
+    """Dedup configuration shared by the pipeline ``Deduper`` and the safety
+    ``SeenCache``. ``enabled`` only gates the pipeline-layer ``Deduper``; the
+    safety-layer ``SeenCache`` always runs."""
+
+    enabled: bool = True
+    ttl_seconds: int = 12 * 3600
+    max_entries: int = 5000
+    sweep_seconds: int = 5 * 60
+
+
+@dataclass
+class TextBatchConfig:
+    """Debounce + merge successive text messages in the same chat."""
+
+    delay_ms: int = 600
+    long_threshold_chars: int = 1000
+    long_delay_ms: int = 2000
+    max_messages: int = 8
+    max_chars: int = 4000
+
+
+@dataclass
+class ChatQueueConfig:
+    """Per-chat serialization queue — forces one-handler-at-a-time per chat."""
+
+    enabled: bool = True
+    merge_while_busy: bool = True
+
+# ---------------------------------------------------------------------------
+# Literal type aliases
+# ---------------------------------------------------------------------------
+
+ReactionNotifications = Literal["off", "own", "all"]
+ReplyModeValue = Literal["auto", "static", "streaming"]
+ChunkMode = Literal["newline", "paragraph", "none"]
+TableMode = Literal["table", "bullets", "code", "off"]
+TagMdMode = Literal["structured", "native"]
+TransportKind = Literal["ws", "webhook"]
+DmPolicy = Literal["open", "allowlist", "blocklist", "disabled"]
+GroupPolicy = Literal["open", "allowlist", "blocklist", "admin_only", "disabled"]
+SenderIdentityField = Literal["open_id", "user_id", "union_id"]
+ChatModeFallback = Optional[Literal["unknown", "group"]]
+SecurityMode = Literal["compat", "audit", "strict"]
+ResourceOverflowPolicy = Literal["audit", "drop"]
+
+
+# ---------------------------------------------------------------------------
+# Policy
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class GroupOverride:
+    """Per-chat overrides for a single group chat_id."""
+
+    policy: Optional[GroupPolicy] = None
+    allowlist: Optional[List[str]] = None
+    blocklist: Optional[List[str]] = None
+    require_mention: Optional[bool] = None
+    respond_to_mention_all: Optional[bool] = None
+    reply_mode: Optional[ReplyModeValue] = None
+    history_limit: Optional[int] = None
+    enabled: Optional[bool] = None
+
+
+@dataclass
+class PolicyConfig:
+    """Admission / routing policy for inbound messages.
+
+    Fields:
+
+    - ``dm_policy`` / ``group_policy`` —
+      ``open`` | ``allowlist`` | ``blocklist`` | ``admin_only`` | ``disabled``
+      (``admin_only`` only valid for groups)
+    - ``require_mention`` — only respond in group chats when @Bot is mentioned
+    - ``respond_to_mention_all`` — treat ``@all`` as a valid mention
+    - ``allow_from`` / ``deny_from`` — sender identities allowed/denied
+      under DM ``allowlist``/``blocklist`` modes, matched by
+      ``sender_identity_fields``
+    - ``group_allowlist`` / ``group_blocklist`` — chat_ids allowed/denied
+      under group ``allowlist``/``blocklist`` modes
+    - ``admins`` — sender identities that bypass every gate (always allowed;
+      required sender list for ``admin_only`` group policy), matched by
+      ``sender_identity_fields``
+    - ``sender_identity_fields`` — identity fields used for sender-based
+      allow/block/admin lists; group chat allow/block lists remain chat_id based
+    - ``group_overrides`` — per-chat overrides keyed by chat_id
+    """
+
+    dm_policy: DmPolicy = "open"
+    group_policy: GroupPolicy = "open"
+    require_mention: bool = True
+    respond_to_mention_all: bool = False
+    allow_from: Optional[List[str]] = None
+    deny_from: Optional[List[str]] = None
+    group_allowlist: Optional[List[str]] = None
+    group_blocklist: Optional[List[str]] = None
+    admins: Optional[List[str]] = None
+    sender_identity_fields: List[SenderIdentityField] = field(
+        default_factory=lambda: ["open_id"]
+    )
+    group_overrides: Dict[str, GroupOverride] = field(default_factory=dict)
+
+
+# ---------------------------------------------------------------------------
+# Inbound
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class MediaCapabilities:
+    image: bool = True
+    audio: bool = True
+    video: bool = True
+    file: bool = True
+    sticker: bool = True
+
+
+@dataclass
+class NameCacheConfig:
+    enabled: bool = True
+    max_size: int = 2000
+    ttl_seconds: int = 24 * 3600
+
+
+@dataclass
+class InboundConfig:
+    """Inbound-pipeline behaviour."""
+
+    expand_merge_forward: bool = True
+    fetch_interactive_card: bool = True
+    reaction_notifications: ReactionNotifications = "own"
+    media_capabilities: MediaCapabilities = field(default_factory=MediaCapabilities)
+    media_max_mb: Optional[int] = None
+    name_cache: NameCacheConfig = field(default_factory=NameCacheConfig)
+    merge_forward_max_depth: int = 3
+    merge_forward_max_items: int = 50
+    drop_self_sent: bool = True
+    inject_chat_mode: bool = False
+    include_raw: bool = True
+    emit_raw_events: bool = False
+
+
+# ---------------------------------------------------------------------------
+# Safety
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class SafetyConfig:
+    """Safety-pipeline configuration.
+
+    Groups dedup, per-chat queue, text batching, and the stale-cutoff window.
+    ``DedupConfig``, ``TextBatchConfig``, and ``ChatQueueConfig`` live in this
+    module; ``MediaBatchConfig`` lives in :mod:`lark_channel.channel.safety.types`
+    and is imported lazily to avoid a circular import through the safety
+    package.
+    """
+
+    dedup: DedupConfig = field(default_factory=DedupConfig)
+    text_batch: TextBatchConfig = field(default_factory=TextBatchConfig)
+    media_batch: Any = field(
+        default_factory=lambda: _media_batch_default()
+    )
+    chat_queue: ChatQueueConfig = field(default_factory=ChatQueueConfig)
+    stale_message_window_ms: int = 30 * 60 * 1000
+
+
+def _media_batch_default():
+    """Avoid importing MediaBatchConfig at module top to prevent circular
+    imports back from the safety package."""
+    from .safety.types import MediaBatchConfig
+    return MediaBatchConfig()
+
+
+# ---------------------------------------------------------------------------
+# Outbound
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class FooterConfig:
+    status: bool = False
+    elapsed: bool = False
+    tokens: bool = False
+    model: bool = False
+    cache: bool = False
+    context: bool = False
+
+
+@dataclass
+class StreamThrottleConfig:
+    min_chars: int = 20
+    max_chars: int = 200
+    idle_ms: int = 300
+
+
+@dataclass
+class MarkdownConverter:
+    enabled: bool = True
+    table_mode: TableMode = "off"
+    tag_md_mode: TagMdMode = "structured"
+
+
+@dataclass
+class PerChatReplyMode:
+    default: ReplyModeValue = "auto"
+    dm: Optional[ReplyModeValue] = None
+    group: Optional[ReplyModeValue] = None
+
+
+@dataclass
+class RetryConfig:
+    """Outbound retry behaviour (see :mod:`..outbound.retry`)."""
+
+    max_attempts: int = 3
+    base_delay_ms: int = 500
+
+
+@dataclass
+class OversizeContext:
+    """Passed to ``OutboundConfig.on_oversize`` when an outbound text exceeds
+    ``text_chunk_limit``.
+
+    Hook contract:
+
+    - Return None or empty string -> SDK falls back to default chunking.
+    - Return a non-empty string -> SDK sends that as a single replacement
+      message; the original long text is dropped.
+    - Raise -> exception propagates to ``channel.send(...)`` caller; no
+      silent fallback.
+    """
+
+    text: str
+    chat_id: str
+    receive_id_type: str
+    estimated_chunks: int
+
+
+@dataclass
+class OutboundConfig:
+    """Outbound-pipeline behaviour: chunking, streaming, retries, SSRF, oversize hook."""
+
+    reply_mode: Union[ReplyModeValue, PerChatReplyMode] = "auto"
+    text_chunk_limit: int = 3500
+    chunk_mode: ChunkMode = "newline"
+    stream_initial_text: str = ""
+    stream_throttle: StreamThrottleConfig = field(default_factory=StreamThrottleConfig)
+    footer: FooterConfig = field(default_factory=FooterConfig)
+    markdown_converter: MarkdownConverter = field(default_factory=MarkdownConverter)
+    retry: RetryConfig = field(default_factory=RetryConfig)
+    # Hostname allowlist for URL-sourced media downloads. Required by the
+    # SSRF guard — without an allowlist, URL downloads are refused. See
+    # :mod:`..outbound.media.ssrf_guard` for the rationale.
+    ssrf_allowlist: Optional[List[str]] = None
+    on_oversize: Optional[
+        Callable[[OversizeContext], "Awaitable[Optional[str]]"]
+    ] = None
+
+
+# ---------------------------------------------------------------------------
+# UAT (user access token)
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class UATConfig:
+    """User access token (device-flow) behaviour."""
+
+    allowed_scopes: Optional[List[str]] = None
+    blocked_scopes: Optional[List[str]] = None
+    refresh_before_expiry_seconds: int = 300
+    device_poll_interval_seconds: int = 5
+
+
+# ---------------------------------------------------------------------------
+# Transport
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class ChatModeCacheConfig:
+    enabled: bool = True
+    max_size: int = 2048
+    ttl_seconds: int = 24 * 3600
+    fallback: ChatModeFallback = None
+
+
+@dataclass
+class MediaCacheConfig:
+    enabled: bool = True
+    root_dir: Optional[Any] = None
+    ttl_seconds: int = 7 * 24 * 3600
+    max_entries: int = 128
+    max_bytes: int = 512 * 1024 * 1024
+    max_file_bytes: int = 50 * 1024 * 1024
+    image_max_bytes: int = 20 * 1024 * 1024
+
+
+@dataclass
+class KeepaliveConfig:
+    enabled: bool = False
+    check_interval_seconds: float = 30.0
+    wake_threshold_seconds: float = 90.0
+    probe_timeout_seconds: float = 5.0
+    failure_threshold: int = 2
+
+
+@dataclass
+class TransportConfig:
+    kind: TransportKind = "ws"
+    auto_reconnect: bool = True
+    headers: Optional[Dict[str, str]] = None
+    http_timeout_seconds: float = 30.0
+    proxy_url: Optional[str] = None
+    trust_env_proxy: Optional[bool] = None
+    keepalive: KeepaliveConfig = field(default_factory=KeepaliveConfig)
+    handshake_timeout_seconds: Optional[float] = None
+
+    # WS tuning (pingInterval / reconnectInterval / reconnectNonce / etc.) is
+    # NOT exposed here intentionally: the Feishu WS endpoint delivers a
+    # server-authoritative ClientConfig on every handshake (and may push
+    # updates mid-session via CONTROL frames) which overrides any client-side
+    # values. User-supplied overrides would be silently replaced and create
+    # a false-control footgun.
+
+
+# ---------------------------------------------------------------------------
+# Security
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class SecurityConfig:
+    mode: SecurityMode = "compat"
+    audit_recorder: Any = field(
+        default_factory=lambda: _security_audit_recorder_default()
+    )
+    allow_unsigned_encrypted_webhook: bool = False
+    allow_insecure_ws: bool = False
+    allow_local_insecure_ws: bool = True
+    strict_error_response: Optional[bool] = None
+    strict_content_text: bool = False
+    legacy_token_cache_fallback: Optional[bool] = None
+    max_ws_fragment_parts: Optional[int] = None
+    max_ws_fragment_bytes: Optional[int] = None
+    max_concurrent_ws_handlers: Optional[int] = None
+    resource_overflow_policy: ResourceOverflowPolicy = "audit"
+
+    def __post_init__(self) -> None:
+        if self.mode not in ("compat", "audit", "strict"):
+            raise ValueError("security mode must be 'compat', 'audit', or 'strict'")
+        if self.resource_overflow_policy not in ("audit", "drop"):
+            raise ValueError("resource_overflow_policy must be 'audit' or 'drop'")
+        if not callable(getattr(self.audit_recorder, "record", None)):
+            raise TypeError("audit_recorder must provide a callable record method")
+        for field_name in (
+            "allow_unsigned_encrypted_webhook",
+            "allow_insecure_ws",
+            "allow_local_insecure_ws",
+            "strict_content_text",
+        ):
+            value = getattr(self, field_name)
+            if not isinstance(value, bool):
+                raise TypeError(f"{field_name} must be a boolean")
+        for field_name in ("strict_error_response", "legacy_token_cache_fallback"):
+            value = getattr(self, field_name)
+            if value is not None and not isinstance(value, bool):
+                raise TypeError(f"{field_name} must be a boolean or None")
+        for field_name in (
+            "max_ws_fragment_parts",
+            "max_ws_fragment_bytes",
+            "max_concurrent_ws_handlers",
+        ):
+            value = getattr(self, field_name)
+            if value is not None and (
+                not isinstance(value, int) or isinstance(value, bool)
+            ):
+                raise TypeError(f"{field_name} must be a positive integer")
+            if value is not None and value <= 0:
+                raise ValueError(f"{field_name} must be a positive integer")
+
+    @property
+    def is_compat(self) -> bool:
+        return self.mode == "compat"
+
+    @property
+    def is_audit(self) -> bool:
+        return self.mode == "audit"
+
+    @property
+    def is_strict(self) -> bool:
+        return self.mode == "strict"
+
+    @property
+    def enforce_strict_error_response(self) -> bool:
+        if self.strict_error_response is not None:
+            return self.strict_error_response
+        return self.is_strict
+
+    @property
+    def effective_legacy_token_cache_fallback(self) -> bool:
+        if self.legacy_token_cache_fallback is not None:
+            return self.legacy_token_cache_fallback
+        return not self.is_strict
+
+
+def _security_audit_recorder_default():
+    from lark_channel.event.security import SecurityAuditRecorder
+    recorder = SecurityAuditRecorder()
+    recorder._lark_channel_default_recorder = True
+    return recorder
+
+
+# ---------------------------------------------------------------------------
+# Top-level
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class ChannelConfig:
+    """Top-level configuration for :class:`FeishuChannel`.
+
+    Groups the five functional areas (``policy`` / ``safety`` / ``inbound`` /
+    ``outbound`` / ``uat``) plus transport settings and the security fields
+    (``encrypt_key`` / ``verification_token``) used by the event dispatcher.
+    Every field has a sensible default; callers typically only need to set
+    ``app_id`` and ``app_secret`` for a minimal setup.
+    """
+
+    app_id: str = ""
+    app_secret: str = ""
+    domain: str = FEISHU_DOMAIN
+    log_level: LogLevel = LogLevel.INFO
+
+    # Event dispatcher uses these regardless of transport kind; webhook mode
+    # also uses ``verification_token`` for request signature verification.
+    encrypt_key: Optional[str] = None
+    verification_token: Optional[str] = None
+
+    transport: TransportConfig = field(default_factory=TransportConfig)
+    chat_mode_cache: ChatModeCacheConfig = field(default_factory=ChatModeCacheConfig)
+
+    policy: PolicyConfig = field(default_factory=PolicyConfig)
+    safety: SafetyConfig = field(default_factory=SafetyConfig)
+    inbound: InboundConfig = field(default_factory=InboundConfig)
+    outbound: OutboundConfig = field(default_factory=OutboundConfig)
+    uat: UATConfig = field(default_factory=UATConfig)
+
+    # Hook for testing / custom HTTP transport.
+    http_executor: Optional[Callable] = None
+    media_cache: MediaCacheConfig = field(default_factory=MediaCacheConfig)
+    security: SecurityConfig = field(default_factory=SecurityConfig)
diff --git a/lark_channel/channel/driver.py b/lark_channel/channel/driver.py
new file mode 100644
index 0000000..9f90736
--- /dev/null
+++ b/lark_channel/channel/driver.py
@@ -0,0 +1,350 @@
+"""Bridge between the channel layer and the underlying `lark_channel.Client`.
+
+Rather than coupling the channel to specific Request/Response types of the
+generated API surface, we adapt them here into plain dict calls that the
+OutboundSender / pipeline expect. This also makes it trivial to mock the
+driver in tests.
+"""
+
+import io
+import json
+from typing import Any, Dict, Optional
+
+from lark_channel.api.im.v1.model.create_message_request import CreateMessageRequest
+from lark_channel.api.im.v1.model.create_message_request_body import CreateMessageRequestBody
+from lark_channel.api.im.v1.model.create_message_reaction_request import CreateMessageReactionRequest
+from lark_channel.api.im.v1.model.create_message_reaction_request_body import CreateMessageReactionRequestBody
+from lark_channel.api.im.v1.model.delete_message_reaction_request import DeleteMessageReactionRequest
+from lark_channel.api.im.v1.model.delete_message_request import DeleteMessageRequest
+from lark_channel.api.im.v1.model.forward_message_request import ForwardMessageRequest
+from lark_channel.api.im.v1.model.forward_message_request_body import ForwardMessageRequestBody
+from lark_channel.api.im.v1.model.get_message_request import GetMessageRequest
+from lark_channel.api.im.v1.model.list_message_reaction_request import ListMessageReactionRequest
+from lark_channel.api.im.v1.model.patch_message_request import PatchMessageRequest
+from lark_channel.api.im.v1.model.patch_message_request_body import PatchMessageRequestBody
+from lark_channel.api.im.v1.model.reply_message_request import ReplyMessageRequest
+from lark_channel.api.im.v1.model.reply_message_request_body import ReplyMessageRequestBody
+from lark_channel.api.im.v1.model.update_message_request import UpdateMessageRequest
+from lark_channel.api.im.v1.model.update_message_request_body import UpdateMessageRequestBody
+from lark_channel.api.im.v1.model.emoji import Emoji
+from lark_channel.client import Client
+from lark_channel.core.json import JSON
+
+from .outbound.sender import SendDriver
+
+
+def _as_upload_stream(data: bytes, name: str) -> io.BytesIO:
+    bio = io.BytesIO(data)
+    bio.name = name
+    return bio
+
+
+def _resp_to_dict(resp: Any) -> Dict[str, Any]:
+    code = getattr(resp, "code", None)
+    msg = getattr(resp, "msg", None)
+    data_obj = getattr(resp, "data", None)
+    out: Dict[str, Any] = {"code": code if code is not None else 0, "msg": msg or ""}
+    if data_obj is not None:
+        try:
+            # Use the SDK's JSON marshaller for consistent dict shape.
+            out["data"] = json.loads(JSON.marshal(data_obj))
+        except Exception:
+            # Best-effort: shallow copy of attrs.
+            out["data"] = {
+                k: getattr(data_obj, k)
+                for k in dir(data_obj)
+                if not k.startswith("_") and not callable(getattr(data_obj, k, None))
+            }
+    return out
+
+
+class LarkClientDriver:
+    """Adapt a `lark_channel.Client` instance into the driver methods we need."""
+
+    def __init__(self, client: Client) -> None:
+        self._client = client
+
+    # -------- send ------------------------------------------------------------
+    async def create_message(
+        self,
+        *,
+        receive_id_type: str,
+        receive_id: str,
+        msg_type: str,
+        content: str,
+        uuid: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        body = (
+            CreateMessageRequestBody.builder()
+            .receive_id(receive_id)
+            .msg_type(msg_type)
+            .content(content)
+        )
+        if uuid:
+            body = body.uuid(uuid)
+        req = (
+            CreateMessageRequest.builder()
+            .receive_id_type(receive_id_type)
+            .request_body(body.build())
+            .build()
+        )
+        resp = await self._client.im.v1.message.acreate(req)
+        return _resp_to_dict(resp)
+
+    async def reply_message(
+        self,
+        *,
+        message_id: str,
+        msg_type: str,
+        content: str,
+        uuid: Optional[str] = None,
+        reply_in_thread: Optional[bool] = None,
+    ) -> Dict[str, Any]:
+        body = ReplyMessageRequestBody.builder().content(content).msg_type(msg_type)
+        if reply_in_thread is not None:
+            body = body.reply_in_thread(reply_in_thread)
+        if uuid:
+            body = body.uuid(uuid)
+        req = (
+            ReplyMessageRequest.builder()
+            .message_id(message_id)
+            .request_body(body.build())
+            .build()
+        )
+        resp = await self._client.im.v1.message.areply(req)
+        return _resp_to_dict(resp)
+
+    async def patch_message(
+        self,
+        *,
+        message_id: str,
+        content: str,
+    ) -> Dict[str, Any]:
+        req = (
+            PatchMessageRequest.builder()
+            .message_id(message_id)
+            .request_body(PatchMessageRequestBody.builder().content(content).build())
+            .build()
+        )
+        resp = await self._client.im.v1.message.apatch(req)
+        return _resp_to_dict(resp)
+
+    async def update_message(
+        self,
+        *,
+        message_id: str,
+        msg_type: str,
+        content: str,
+    ) -> Dict[str, Any]:
+        body = (
+            UpdateMessageRequestBody.builder()
+            .msg_type(msg_type)
+            .content(content)
+            .build()
+        )
+        req = (
+            UpdateMessageRequest.builder()
+            .message_id(message_id)
+            .request_body(body)
+            .build()
+        )
+        resp = await self._client.im.v1.message.aupdate(req)
+        return _resp_to_dict(resp)
+
+    async def delete_message(self, *, message_id: str) -> Dict[str, Any]:
+        req = DeleteMessageRequest.builder().message_id(message_id).build()
+        resp = await self._client.im.v1.message.adelete(req)
+        return _resp_to_dict(resp)
+
+    async def forward_message(
+        self,
+        *,
+        message_id: str,
+        chat_id: str,
+    ) -> Dict[str, Any]:
+        body = ForwardMessageRequestBody.builder().receive_id(chat_id).build()
+        req = (
+            ForwardMessageRequest.builder()
+            .message_id(message_id)
+            .receive_id_type("chat_id")
+            .request_body(body)
+            .build()
+        )
+        resp = await self._client.im.v1.message.aforward(req)
+        return _resp_to_dict(resp)
+
+    async def fetch_message(self, message_id: str) -> Dict[str, Any]:
+        req = GetMessageRequest.builder().message_id(message_id).build()
+        resp = await self._client.im.v1.message.aget(req)
+        return _resp_to_dict(resp)
+
+    async def add_reaction(self, *, message_id: str, emoji_type: str) -> Dict[str, Any]:
+        body = (
+            CreateMessageReactionRequestBody.builder()
+            .reaction_type(Emoji.builder().emoji_type(emoji_type).build())
+            .build()
+        )
+        req = (
+            CreateMessageReactionRequest.builder()
+            .message_id(message_id)
+            .request_body(body)
+            .build()
+        )
+        resp = await self._client.im.v1.message_reaction.acreate(req)
+        return _resp_to_dict(resp)
+
+    async def remove_reaction(self, *, message_id: str, reaction_id: str) -> Dict[str, Any]:
+        req = (
+            DeleteMessageReactionRequest.builder()
+            .message_id(message_id)
+            .reaction_id(reaction_id)
+            .build()
+        )
+        resp = await self._client.im.v1.message_reaction.adelete(req)
+        return _resp_to_dict(resp)
+
+    async def list_reactions(
+        self,
+        *,
+        message_id: str,
+        emoji_type: Optional[str] = None,
+        page_token: Optional[str] = None,
+        page_size: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        builder = ListMessageReactionRequest.builder().message_id(message_id)
+        if emoji_type:
+            builder = builder.reaction_type(emoji_type)
+        if page_token:
+            builder = builder.page_token(page_token)
+        if page_size is not None:
+            builder = builder.page_size(page_size)
+        req = builder.build()
+        resp = await self._client.im.v1.message_reaction.alist(req)
+        return _resp_to_dict(resp)
+
+    # -------- media upload ----------------------------------------------------
+    async def upload_image(self, *, data: bytes, file_name: str = "") -> Dict[str, Any]:
+        try:
+            from lark_channel.api.im.v1.model.create_image_request import CreateImageRequest
+            from lark_channel.api.im.v1.model.create_image_request_body import CreateImageRequestBody
+        except ImportError:  # pragma: no cover
+            return {"code": -1, "msg": "image upload model missing"}
+        # The SDK's multipart serializer (`Files.extract_files`) only picks up
+        # fields whose value is an `io.IOBase`; raw `bytes` are silently
+        # dropped, which makes the server reject the request as 234001
+        # "Invalid request param". Wrap the buffer in a BytesIO and attach a
+        # filename so the multipart part is well-formed.
+        body = (
+            CreateImageRequestBody.builder()
+            .image_type("message")
+            .image(_as_upload_stream(data, file_name or "image"))
+            .build()
+        )
+        req = CreateImageRequest.builder().request_body(body).build()
+        resp = await self._client.im.v1.image.acreate(req)
+        return _resp_to_dict(resp)
+
+    async def upload_file(
+        self,
+        *,
+        data: bytes,
+        file_name: str = "",
+        file_type: str = "stream",
+    ) -> Dict[str, Any]:
+        try:
+            from lark_channel.api.im.v1.model.create_file_request import CreateFileRequest
+            from lark_channel.api.im.v1.model.create_file_request_body import CreateFileRequestBody
+        except ImportError:  # pragma: no cover
+            return {"code": -1, "msg": "file upload model missing"}
+        name = file_name or "upload"
+        body = (
+            CreateFileRequestBody.builder()
+            .file_type(file_type)
+            .file_name(name)
+            .file(_as_upload_stream(data, name))
+            .build()
+        )
+        req = CreateFileRequest.builder().request_body(body).build()
+        resp = await self._client.im.v1.file.acreate(req)
+        return _resp_to_dict(resp)
+
+    # -------- cardkit preallocation ------------------------------------------
+    async def cardkit_create(self, *, body: Dict[str, Any]) -> Dict[str, Any]:
+        """POST ``/open-apis/cardkit/v1/card``. ``body`` is ``{type, data}``."""
+        from lark_channel.api.cardkit.v1.model.create_card_request import CreateCardRequest
+        from lark_channel.api.cardkit.v1.model.create_card_request_body import (
+            CreateCardRequestBody,
+        )
+
+        rb = (
+            CreateCardRequestBody.builder()
+            .type(body.get("type") or "card_json")
+            .data(body.get("data") or "")
+            .build()
+        )
+        req = CreateCardRequest.builder().request_body(rb).build()
+        resp = await self._client.cardkit.v1.card.acreate(req)
+        return _resp_to_dict(resp)
+
+    async def cardkit_update_element(
+        self, *, card_id: str, element_id: str, body: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """POST ``/open-apis/cardkit/v1/card/{card_id}/element/{element_id}/content``."""
+        from lark_channel.api.cardkit.v1.model.content_card_element_request import (
+            ContentCardElementRequest,
+        )
+        from lark_channel.api.cardkit.v1.model.content_card_element_request_body import (
+            ContentCardElementRequestBody,
+        )
+
+        rb_b = ContentCardElementRequestBody.builder().content(
+            body.get("content") or ""
+        )
+        seq = body.get("sequence")
+        if seq is not None:
+            rb_b = rb_b.sequence(int(seq))
+        req = (
+            ContentCardElementRequest.builder()
+            .card_id(card_id)
+            .element_id(element_id)
+            .request_body(rb_b.build())
+            .build()
+        )
+        resp = await self._client.cardkit.v1.card_element.acontent(req)
+        return _resp_to_dict(resp)
+
+    async def cardkit_update_settings(
+        self, *, card_id: str, body: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """POST ``/open-apis/cardkit/v1/card/{card_id}/settings``."""
+        from lark_channel.api.cardkit.v1.model.settings_card_request import (
+            SettingsCardRequest,
+        )
+        from lark_channel.api.cardkit.v1.model.settings_card_request_body import (
+            SettingsCardRequestBody,
+        )
+
+        rb_b = SettingsCardRequestBody.builder().settings(body.get("settings") or "")
+        seq = body.get("sequence")
+        if seq is not None:
+            rb_b = rb_b.sequence(int(seq))
+        req = (
+            SettingsCardRequest.builder()
+            .card_id(card_id)
+            .request_body(rb_b.build())
+            .build()
+        )
+        resp = await self._client.cardkit.v1.card.asettings(req)
+        return _resp_to_dict(resp)
+
+    # -------- public helpers --------------------------------------------------
+    def send_driver(self) -> SendDriver:
+        return SendDriver(
+            create_message=self.create_message,
+            reply_message=self.reply_message,
+            patch_message=self.patch_message,
+            delete_message=self.delete_message,
+            forward_message=self.forward_message,
+            upload_image=self.upload_image,
+            upload_file=self.upload_file,
+        )
diff --git a/lark_channel/channel/errors.py b/lark_channel/channel/errors.py
new file mode 100644
index 0000000..52f33a5
--- /dev/null
+++ b/lark_channel/channel/errors.py
@@ -0,0 +1,220 @@
+"""Channel error types and classification.
+
+Single canonical enum: `FeishuChannelErrorCode` — 10 values covering the
+taxonomy of failures surfaced by the outbound / inbound pipelines.
+"""
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Dict, Optional
+
+
+class FeishuChannelErrorCode(str, Enum):
+    """Channel-layer error taxonomy (10 canonical values)."""
+
+    FORMAT_ERROR = "format_error"
+    TARGET_REVOKED = "target_revoked"
+    RATE_LIMITED = "rate_limited"
+    PERMISSION_DENIED = "permission_denied"
+    UPLOAD_FAILED = "upload_failed"
+    DOWNLOAD_FAILED = "download_failed"
+    SSRF_BLOCKED = "ssrf_blocked"
+    SEND_TIMEOUT = "send_timeout"
+    NOT_CONNECTED = "not_connected"
+    UNKNOWN = "unknown"
+
+
+@dataclass
+class SendError:
+    code: FeishuChannelErrorCode
+    retryable: bool
+    hint: Optional[str] = None
+    raw_code: Optional[int] = None
+    # Suggested minimum wait before retrying. Populated when the upstream
+    # response carries a ``Retry-After`` header (seconds) or an equivalent
+    # rate-limit hint. ``None`` means "use default backoff".
+    retry_after_seconds: Optional[float] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "code": self.code.value,
+            "retryable": self.retryable,
+            "hint": self.hint,
+            "raw_code": self.raw_code,
+            "retry_after_seconds": self.retry_after_seconds,
+        }
+
+
+# Feishu API error code buckets
+_TOKEN_INVALID_CODES = {99991663, 99991664, 99991665, 99991666, 99991668}
+# 99991402 / 11020 / 11021 are genuine "too many requests" backpressure codes;
+# 99991400 / 99991401 used to be miscategorized here but are actually auth /
+# permission denials ("invalid app_ticket" / "invalid access_token") so they
+# live in _PERMISSION_CODES below.
+_RATE_LIMIT_CODES = {99991402, 11020, 11021}
+# 230001 = "invalid message content" (malformed body); NOT a revoked target.
+# Do NOT put it in _TARGET_REVOKED_CODES — that triggers the wrong fallback
+# (reply-gone → fresh create) and hides the real schema bug.
+_TARGET_REVOKED_CODES = {230002, 230005, 230020, 230017}
+_LENGTH_EXCEED_CODES = {230021, 230022}
+_PERMISSION_CODES = {
+    99991400, 99991401,  # auth/token denials (not rate-limit)
+    99991672, 99991679, 99991680, 99991681,
+    230003, 230010,
+}
+_FORMAT_CODES = {
+    230001,  # invalid message content — shape mismatch, malformed JSON, etc.
+    230099,  # CardKit "failed to create card content"
+}
+
+
+def classify_error(raw_code: int, msg: str = "") -> SendError:
+    """Classify a Feishu API error code into a `SendError`."""
+    if raw_code == 0:
+        return SendError(code=FeishuChannelErrorCode.UNKNOWN, retryable=False, raw_code=0, hint=msg)
+    if raw_code in _TOKEN_INVALID_CODES:
+        return SendError(code=FeishuChannelErrorCode.PERMISSION_DENIED, retryable=True, raw_code=raw_code, hint=msg)
+    if raw_code in _RATE_LIMIT_CODES:
+        return SendError(code=FeishuChannelErrorCode.RATE_LIMITED, retryable=True, raw_code=raw_code, hint=msg)
+    if raw_code in _TARGET_REVOKED_CODES:
+        return SendError(code=FeishuChannelErrorCode.TARGET_REVOKED, retryable=False, raw_code=raw_code, hint=msg)
+    if raw_code in _LENGTH_EXCEED_CODES:
+        return SendError(code=FeishuChannelErrorCode.FORMAT_ERROR, retryable=False, raw_code=raw_code, hint=msg)
+    if raw_code in _PERMISSION_CODES:
+        return SendError(code=FeishuChannelErrorCode.PERMISSION_DENIED, retryable=False, raw_code=raw_code, hint=msg)
+    if raw_code in _FORMAT_CODES:
+        return SendError(code=FeishuChannelErrorCode.FORMAT_ERROR, retryable=False, raw_code=raw_code, hint=msg)
+    if 500 <= raw_code < 600 or 50000 <= raw_code < 60000:
+        return SendError(code=FeishuChannelErrorCode.UNKNOWN, retryable=True, raw_code=raw_code, hint=msg)
+    return SendError(code=FeishuChannelErrorCode.UNKNOWN, retryable=False, raw_code=raw_code, hint=msg)
+
+
+class _ChannelError(Exception):
+    """Base class for channel-layer errors that escape user handlers.
+
+    Kept as an internal inheritance root; user-facing code should catch
+    :class:`FeishuChannelError`.
+    """
+
+
+class UATAuthError(_ChannelError):
+    """UAT device-flow authorization failed or was cancelled."""
+
+
+class PolicyDeniedError(_ChannelError):
+    """Raised internally when a policy gate blocks a message."""
+
+
+class FeishuChannelError(_ChannelError):
+    """Unified channel error raised by the outbound / inbound pipelines.
+
+    Prefer the ``raise FeishuChannelError(...) from original_exc`` idiom to
+    preserve the underlying cause in tracebacks. The ``cause=`` kwarg below is
+    kept for back-compat: when supplied it is wired to ``__cause__`` so
+    ``traceback.print_exc()`` still shows the chain.
+    """
+
+    def __init__(
+        self,
+        code: FeishuChannelErrorCode,
+        message: str = "",
+        *,
+        cause: Optional[BaseException] = None,
+        context: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        resolved = message or code.value
+        super().__init__(resolved)
+        self.code = code
+        # Stored explicitly so ``__repr__`` / diagnostics don't depend on the
+        # fragile ``self.args[0]`` indexing.
+        self.message: str = resolved
+        self.context = context or {}
+        # Wire to Python's exception-chaining machinery so tracebacks show the
+        # root cause. Previously this kwarg was stored but never surfaced.
+        if cause is not None:
+            self.__cause__ = cause
+
+    @property
+    def cause(self) -> Optional[BaseException]:
+        """Back-compat shim: returns the wired ``__cause__``."""
+        c = self.__cause__
+        return c if isinstance(c, BaseException) else None
+
+    def __repr__(self) -> str:
+        return (
+            f"FeishuChannelError(code={self.code.value}, "
+            f"message={self.message!r})"
+        )
+
+
+class OutboundSendError(FeishuChannelError):
+    """Exception form of :class:`SendError` — what ``on('error', ...)`` handlers
+    actually receive when a send/stream call returns ``SendResult.fail(...)``.
+
+    Subscribers consume errors uniformly (``logger.exception``,
+    ``traceback.format_exception``, Sentry, etc.); these expect a real
+    :class:`Exception` with ``__traceback__``. Forwarding a bare
+    :class:`SendError` dataclass would break that contract. This wrapper
+    preserves every field of the original ``SendError`` and is a subclass of
+    :class:`FeishuChannelError`, so existing ``except FeishuChannelError``
+    catches still work.
+
+    The original ``SendResult.fail(...)`` returned to the direct caller is
+    unchanged — wrapping happens only on the forwarding path.
+    """
+
+    def __init__(self, send_error: SendError) -> None:
+        super().__init__(
+            send_error.code,
+            send_error.hint or send_error.code.value,
+        )
+        self.send_error = send_error
+        self.retryable = send_error.retryable
+        self.raw_code = send_error.raw_code
+        self.retry_after_seconds = send_error.retry_after_seconds
+        self.hint = send_error.hint
+
+    def __repr__(self) -> str:
+        return (
+            f"OutboundSendError(code={self.code.value}, "
+            f"raw_code={self.raw_code}, retryable={self.retryable}, "
+            f"hint={self.hint!r})"
+        )
+
+
+# ---- Classification helpers -------------------------------------------------
+
+
+def classify_api_error(raw_code: int, msg: str = "") -> FeishuChannelErrorCode:
+    """Map a Feishu API error code to a :class:`FeishuChannelErrorCode`.
+
+    Thin shim around :func:`classify_error` — use that directly when you need
+    the full ``SendError`` (retryable flag, raw code, hint). Kept for callers
+    that only care about the taxonomy code.
+    """
+    return classify_error(raw_code, msg).code
+
+
+def classify_http_status(status: int) -> FeishuChannelErrorCode:
+    """Map an HTTP status code to a ``FeishuChannelErrorCode``."""
+    if status == 429:
+        return FeishuChannelErrorCode.RATE_LIMITED
+    if status in (401, 403):
+        return FeishuChannelErrorCode.PERMISSION_DENIED
+    if status == 404:
+        return FeishuChannelErrorCode.TARGET_REVOKED
+    if status == 400:
+        return FeishuChannelErrorCode.FORMAT_ERROR
+    return FeishuChannelErrorCode.UNKNOWN
+
+
+def is_retryable(code: FeishuChannelErrorCode) -> bool:
+    return code in (FeishuChannelErrorCode.RATE_LIMITED, FeishuChannelErrorCode.UNKNOWN)
+
+
+def is_reply_target_gone(code: FeishuChannelErrorCode) -> bool:
+    return code == FeishuChannelErrorCode.TARGET_REVOKED
+
+
+def is_format_error(code: FeishuChannelErrorCode) -> bool:
+    return code == FeishuChannelErrorCode.FORMAT_ERROR
diff --git a/lark_channel/channel/events.py b/lark_channel/channel/events.py
new file mode 100644
index 0000000..a03cf22
--- /dev/null
+++ b/lark_channel/channel/events.py
@@ -0,0 +1,71 @@
+"""Event-name constants and :data:`ChannelEventName` Literal type.
+
+``FeishuChannel.on(name, handler)`` accepts any of the strings in
+:data:`ChannelEventName`. Passing an unknown name is not a hard error — it
+logs a warning at runtime — so typos like ``channel.on("messageReceive", ...)``
+(the correct name is ``"message"``) will otherwise fail silently.
+
+Two ways to guard against that:
+
+1. **Use the constants** (``Events.MESSAGE``)::
+
+        channel.on(Events.MESSAGE, handler)
+
+2. **Type-check with** :data:`ChannelEventName`::
+
+        from lark_channel import ChannelEventName
+
+        event: ChannelEventName = "message"  # mypy/pyright catches typos
+        channel.on(event, handler)
+
+   ``FeishuChannel.on``'s type hint uses this Literal alias, so any type
+   checker will flag unknown event names in callers.
+"""
+
+from typing import Literal
+
+
+#: All event names accepted by :meth:`FeishuChannel.on`. The alias table in
+#: :mod:`._coerce` normalizes snake_case aliases (``"bot_added"``, ``"card_action"``,
+#: etc.) onto these canonical forms.
+ChannelEventName = Literal[
+    "message",
+    "cardAction",
+    "reaction",
+    "botAdded",
+    "botLeave",
+    "messageRead",
+    "reject",
+    "comment",
+    "raw",
+    "reconnecting",
+    "reconnected",
+    "error",
+]
+
+
+class Events:
+    """String constants for :meth:`FeishuChannel.on` event names.
+
+    Prefer these over string literals so typos surface as ``AttributeError``
+    at import time instead of a runtime no-op::
+
+        channel.on(Events.MESSAGE, on_message)
+        channel.on(Events.CARD_ACTION, on_card_action)
+    """
+
+    MESSAGE = "message"
+    CARD_ACTION = "cardAction"
+    REACTION = "reaction"
+    BOT_ADDED = "botAdded"
+    BOT_LEAVE = "botLeave"
+    MESSAGE_READ = "messageRead"
+    REJECT = "reject"
+    COMMENT = "comment"
+    RAW = "raw"
+    RECONNECTING = "reconnecting"
+    RECONNECTED = "reconnected"
+    ERROR = "error"
+
+
+__all__ = ["ChannelEventName", "Events"]
diff --git a/lark_channel/channel/identity.py b/lark_channel/channel/identity.py
new file mode 100644
index 0000000..b36fae8
--- /dev/null
+++ b/lark_channel/channel/identity.py
@@ -0,0 +1,126 @@
+"""Identity resolution with a bounded LRU + TTL name cache.
+
+Channel handlers often need to turn an open_id into a display name (for
+mentions, merge_forward summaries, etc.). This module:
+
+- Caches resolved (open_id → name) entries with a TTL.
+- Batches lookups via `resolve_names(open_ids)`.
+- Is transport-agnostic: a `ContactLookupFn` is injected.
+"""
+
+import inspect
+import threading
+import time
+from collections import OrderedDict
+from typing import Awaitable, Callable, Dict, Iterable, List, Optional, Union
+
+from lark_channel.core.log import logger
+
+from .config import NameCacheConfig
+from .types import Identity
+
+
+ContactLookupResult = Dict[str, Union[Identity, str]]
+ContactLookupFn = Callable[
+    [List[str]], Union[ContactLookupResult, Awaitable[ContactLookupResult]]
+]
+"""Signature: given a list of open_ids, return dict[open_id, Identity | str].
+
+Either sync or awaitable return is accepted.
+"""
+
+
+class NameCache:
+    """Thread-safe bounded LRU + TTL cache of open_id → display_name."""
+
+    def __init__(self, config: Optional[NameCacheConfig] = None) -> None:
+        config = config or NameCacheConfig()
+        self._enabled = config.enabled
+        self._max = config.max_size
+        self._ttl = config.ttl_seconds
+        self._data: "OrderedDict[str, tuple[str, float]]" = OrderedDict()
+        self._lock = threading.Lock()
+
+    def get(self, open_id: str) -> Optional[str]:
+        if not self._enabled or not open_id:
+            return None
+        with self._lock:
+            entry = self._data.get(open_id)
+            if entry is None:
+                return None
+            name, exp = entry
+            if exp <= time.time():
+                self._data.pop(open_id, None)
+                return None
+            self._data.move_to_end(open_id)
+            return name
+
+    def put(self, open_id: str, name: str) -> None:
+        if not self._enabled or not open_id or not name:
+            return
+        with self._lock:
+            self._data[open_id] = (name, time.time() + self._ttl)
+            self._data.move_to_end(open_id)
+            while len(self._data) > self._max:
+                self._data.popitem(last=False)
+
+    def invalidate(self, open_id: str) -> None:
+        with self._lock:
+            self._data.pop(open_id, None)
+
+
+class IdentityResolver:
+    """Async-friendly name resolver."""
+
+    def __init__(
+        self,
+        lookup: Optional[ContactLookupFn],
+        cache: Optional[NameCache] = None,
+    ) -> None:
+        self._lookup = lookup
+        self._cache = cache or NameCache()
+
+    @property
+    def cache(self) -> NameCache:
+        return self._cache
+
+    async def resolve_names(self, open_ids: Iterable[str]) -> Dict[str, str]:
+        """Batch resolve. Returns dict[open_id, name]; missing keys indicate
+        lookup failure. Populates the cache on success.
+        """
+        ids = [o for o in open_ids if o]
+        if not ids:
+            return {}
+
+        out: Dict[str, str] = {}
+        missing: List[str] = []
+        for oid in ids:
+            cached = self._cache.get(oid)
+            if cached:
+                out[oid] = cached
+            else:
+                missing.append(oid)
+
+        if missing and self._lookup is not None:
+            try:
+                result = self._lookup(missing)
+                if inspect.isawaitable(result):
+                    result = await result
+                if isinstance(result, dict):
+                    for oid, ident in result.items():
+                        if isinstance(ident, Identity) and ident.display_name:
+                            self._cache.put(oid, ident.display_name)
+                            out[oid] = ident.display_name
+                        elif isinstance(ident, str) and ident:
+                            self._cache.put(oid, ident)
+                            out[oid] = ident
+            except Exception as e:  # pragma: no cover - defensive
+                logger.warning("identity: lookup failed for %s ids: %s", len(missing), e)
+
+        return out
+
+    async def resolve(self, open_id: str) -> Identity:
+        if not open_id:
+            return Identity(open_id="")
+        names = await self.resolve_names([open_id])
+        return Identity(open_id=open_id, display_name=names.get(open_id))
diff --git a/lark_channel/channel/keepalive.py b/lark_channel/channel/keepalive.py
new file mode 100644
index 0000000..7fbd6f7
--- /dev/null
+++ b/lark_channel/channel/keepalive.py
@@ -0,0 +1,42 @@
+import inspect
+import time
+from typing import Callable
+
+from .config import KeepaliveConfig
+
+
+class KeepaliveWatchdog:
+    def __init__(
+        self,
+        *,
+        config: KeepaliveConfig,
+        probe: Callable[[], bool],
+        reconnect: Callable[[], None],
+        clock: Callable[[], float] = time.monotonic,
+    ) -> None:
+        self._config = config
+        self._probe = probe
+        self._reconnect = reconnect
+        self._clock = clock
+        self._last_tick = clock()
+        self._failures = 0
+
+    async def run_once(self) -> None:
+        if not self._config.enabled:
+            return
+        now = self._clock()
+        elapsed = now - self._last_tick
+        self._last_tick = now
+        if elapsed < self._config.wake_threshold_seconds:
+            self._failures = 0
+            return
+        ok = self._probe()
+        if inspect.isawaitable(ok):
+            ok = await ok
+        if ok:
+            self._failures = 0
+            return
+        self._failures += 1
+        if self._failures >= self._config.failure_threshold:
+            self._failures = 0
+            self._reconnect()
diff --git a/lark_channel/channel/media_cache.py b/lark_channel/channel/media_cache.py
new file mode 100644
index 0000000..090793f
--- /dev/null
+++ b/lark_channel/channel/media_cache.py
@@ -0,0 +1,386 @@
+import hashlib
+import mimetypes
+import os
+import tempfile
+import time
+from pathlib import Path
+
+from .config import MediaCacheConfig
+from .types import CachedResource, ResourceDescriptor
+
+
+class MediaResourceCache:
+    def __init__(self, config: MediaCacheConfig) -> None:
+        self._config = config
+        self._root = (
+            Path(config.root_dir)
+            if config.root_dir is not None
+            else Path.home() / ".cache" / "lark-channel-sdk"
+        )
+        self._key_index = {}
+
+    async def resolve(self, *, message_id: str, resource: ResourceDescriptor, downloader):
+        if not self._config.enabled:
+            return self._result(
+                "skipped",
+                reason="cache_disabled",
+                message_id=message_id,
+                resource=resource,
+            )
+        if resource.type not in ("image", "file"):
+            return self._result(
+                "rejected",
+                reason="unsupported_resource_type",
+                message_id=message_id,
+                resource=resource,
+            )
+
+        if not self._can_store():
+            return self._result(
+                "skipped",
+                reason="cache_limit",
+                message_id=message_id,
+                resource=resource,
+            )
+
+        cache_key = (message_id, resource.type, resource.file_key)
+        cached = self._key_index.get(cache_key)
+        if cached is not None and cached.path is not None:
+            if (
+                self._path_exists(cached.path)
+                and self._is_fresh(cached.path)
+                and self._is_valid_cache_file(
+                    cached.path,
+                    cached.sha256 or "",
+                    cached.size if cached.size is not None else -1,
+                )
+            ):
+                if self._touch(cached.path):
+                    return cached
+                self._key_index.pop(cache_key, None)
+            else:
+                self._safe_unlink(cached.path)
+                self._key_index.pop(cache_key, None)
+
+        body, meta = await downloader(
+            message_id=message_id,
+            file_key=resource.file_key,
+            resource_type=resource.type,
+        )
+        if body is None:
+            return self._result(
+                "rejected",
+                reason="download_failed",
+                message_id=message_id,
+                resource=resource,
+            )
+
+        size = len(body)
+        mime_type = _normalize_mime_type(meta)
+        if resource.type == "image" and mime_type == "application/octet-stream":
+            mime_type = _sniff_image_mime_type(body) or mime_type
+        if size > self._config.max_file_bytes:
+            return self._result(
+                "rejected",
+                reason="max_file_bytes",
+                message_id=message_id,
+                resource=resource,
+                mime_type=mime_type,
+                size=size,
+            )
+        if size > self._config.max_bytes:
+            return self._result(
+                "rejected",
+                reason="max_bytes",
+                message_id=message_id,
+                resource=resource,
+                mime_type=mime_type,
+                size=size,
+            )
+        if resource.type == "image" and size > self._config.image_max_bytes:
+            return self._result(
+                "rejected",
+                reason="image_max_bytes",
+                message_id=message_id,
+                resource=resource,
+                mime_type=mime_type,
+                size=size,
+            )
+        if resource.type == "image" and mime_type not in {
+            "image/png",
+            "image/jpeg",
+            "image/jpg",
+            "image/gif",
+            "image/webp",
+        }:
+            return self._result(
+                "rejected",
+                reason="unsupported_mime_type",
+                message_id=message_id,
+                resource=resource,
+                mime_type=mime_type,
+                size=size,
+            )
+
+        digest = hashlib.sha256(body).hexdigest()
+        suffix = _suffix_for(mime_type)
+        try:
+            self._root.mkdir(parents=True, exist_ok=True)
+        except OSError:
+            return self._result(
+                "rejected",
+                reason="write_failed",
+                message_id=message_id,
+                resource=resource,
+                mime_type=mime_type,
+                size=size,
+            )
+        path = self._root / f"{digest}{suffix}"
+        if self._path_exists(path) and not self._is_valid_cache_file(path, digest, size):
+            self._safe_unlink(path)
+        if not self._is_valid_cache_file(path, digest, size) and not self._write_atomic(path, body):
+            return self._result(
+                "rejected",
+                reason="write_failed",
+                message_id=message_id,
+                resource=resource,
+                mime_type=mime_type,
+                size=size,
+            )
+        if not self._touch(path):
+            return self._result(
+                "rejected",
+                reason="write_failed",
+                message_id=message_id,
+                resource=resource,
+                mime_type=mime_type,
+                size=size,
+            )
+        cached = self._result(
+            "cached",
+            message_id=message_id,
+            resource=resource,
+            path=path,
+            sha256=digest,
+            mime_type=mime_type,
+            size=size,
+        )
+        self._key_index[cache_key] = cached
+        self.gc(protect=path)
+        if not self._path_exists(path):
+            self._key_index.pop(cache_key, None)
+            return self._result(
+                "rejected",
+                reason="cache_evicted",
+                message_id=message_id,
+                resource=resource,
+                mime_type=mime_type,
+                size=size,
+            )
+        return cached
+
+    def gc(self, *, protect=None) -> None:
+        if not self._path_exists(self._root):
+            return
+        now = time.time()
+        ttl_seconds = self._config.ttl_seconds
+        entries = self._entries()
+        for path in entries:
+            if path == protect:
+                continue
+            try:
+                expired = ttl_seconds <= 0 or now - path.stat().st_mtime > ttl_seconds
+            except OSError:
+                expired = True
+            if expired:
+                self._safe_unlink(path)
+        entries = self._entries()
+        max_entries = max(self._config.max_entries, 0)
+        while len(entries) > max_entries:
+            victim = self._oldest_unprotected(entries, protect)
+            if victim is None:
+                break
+            self._safe_unlink(victim)
+            entries = [path for path in entries if path != victim]
+        max_bytes = max(self._config.max_bytes, 0)
+        while entries and self._total_size(entries) > max_bytes:
+            victim = self._oldest_unprotected(entries, protect)
+            if victim is None:
+                break
+            self._safe_unlink(victim)
+            entries = [path for path in entries if path != victim]
+        self._key_index = {
+            key: value
+            for key, value in self._key_index.items()
+            if value.path is not None and self._path_exists(value.path)
+        }
+
+    def _entries(self):
+        try:
+            candidates = list(self._root.iterdir())
+        except OSError:
+            return []
+        entries = []
+        for path in candidates:
+            try:
+                if path.is_file() and not path.name.startswith("."):
+                    path.stat()
+                    entries.append(path)
+            except OSError:
+                continue
+        return sorted(entries, key=lambda path: self._mtime(path))
+
+    def _can_store(self) -> bool:
+        return (
+            self._config.ttl_seconds > 0
+            and self._config.max_entries > 0
+            and self._config.max_bytes > 0
+        )
+
+    def _is_fresh(self, path) -> bool:
+        try:
+            return time.time() - path.stat().st_mtime <= self._config.ttl_seconds
+        except OSError:
+            return False
+
+    def _write_atomic(self, path, body: bytes) -> bool:
+        tmp_path = None
+        try:
+            fd, tmp_name = tempfile.mkstemp(
+                prefix=f".{path.stem}.",
+                suffix=".tmp",
+                dir=str(self._root),
+            )
+            tmp_path = Path(tmp_name)
+            with os.fdopen(fd, "wb") as tmp:
+                tmp.write(body)
+            os.replace(tmp_path, path)
+            return True
+        except OSError:
+            if tmp_path is not None:
+                self._safe_unlink(tmp_path)
+            return False
+
+    def _is_valid_cache_file(self, path, digest: str, size: int) -> bool:
+        try:
+            if path.is_symlink() or not path.is_file():
+                return False
+            if path.stat().st_size != size:
+                return False
+        except OSError:
+            return False
+        return self._sha256_file(path) == digest
+
+    def _touch(self, path) -> bool:
+        try:
+            os.utime(path, None)
+            return True
+        except OSError:
+            return False
+
+    @staticmethod
+    def _path_exists(path) -> bool:
+        try:
+            return path.exists()
+        except OSError:
+            return False
+
+    @staticmethod
+    def _safe_unlink(path) -> bool:
+        try:
+            path.unlink(missing_ok=True)
+            return True
+        except OSError:
+            return False
+
+    @staticmethod
+    def _sha256_file(path) -> str:
+        digest = hashlib.sha256()
+        try:
+            with path.open("rb") as fp:
+                for chunk in iter(lambda: fp.read(1024 * 1024), b""):
+                    digest.update(chunk)
+        except OSError:
+            return ""
+        return digest.hexdigest()
+
+    @staticmethod
+    def _mtime(path) -> float:
+        try:
+            return path.stat().st_mtime
+        except OSError:
+            return 0.0
+
+    @staticmethod
+    def _total_size(paths) -> int:
+        total = 0
+        for path in paths:
+            try:
+                total += path.stat().st_size
+            except OSError:
+                continue
+        return total
+
+    @staticmethod
+    def _oldest_unprotected(paths, protect):
+        for path in paths:
+            if path != protect:
+                return path
+        return None
+
+    @staticmethod
+    def _result(
+        decision: str,
+        *,
+        message_id: str,
+        resource: ResourceDescriptor,
+        reason=None,
+        path=None,
+        sha256=None,
+        mime_type=None,
+        size=None,
+    ) -> CachedResource:
+        return CachedResource(
+            decision=decision,
+            reason=reason,
+            path=path,
+            sha256=sha256,
+            mime_type=mime_type,
+            size=size,
+            source_message_id=message_id,
+            source_file_key=resource.file_key,
+            resource_type=resource.type,
+        )
+
+
+def _normalize_mime_type(meta: str) -> str:
+    if not meta:
+        return "application/octet-stream"
+    if "/" in meta:
+        return meta.split(";", 1)[0].strip().lower()
+    guessed, _ = mimetypes.guess_type(meta)
+    return guessed or "application/octet-stream"
+
+
+def _suffix_for(mime_type: str) -> str:
+    if mime_type == "image/png":
+        return ".png"
+    if mime_type in ("image/jpeg", "image/jpg"):
+        return ".jpg"
+    if mime_type == "image/gif":
+        return ".gif"
+    if mime_type == "image/webp":
+        return ".webp"
+    return mimetypes.guess_extension(mime_type) or ".bin"
+
+
+def _sniff_image_mime_type(body: bytes) -> str:
+    if body.startswith(b"\x89PNG\r\n\x1a\n"):
+        return "image/png"
+    if body.startswith(b"\xff\xd8\xff"):
+        return "image/jpeg"
+    if body.startswith((b"GIF87a", b"GIF89a")):
+        return "image/gif"
+    if len(body) >= 12 and body[:4] == b"RIFF" and body[8:12] == b"WEBP":
+        return "image/webp"
+    return ""
diff --git a/lark_channel/channel/normalize/__init__.py b/lark_channel/channel/normalize/__init__.py
new file mode 100644
index 0000000..f1ab15a
--- /dev/null
+++ b/lark_channel/channel/normalize/__init__.py
@@ -0,0 +1,37 @@
+"""Normalize: raw Lark events → structured InboundMessage / *Event shapes.
+
+Houses the inbound pipeline, message-content registry, dedup store, mention
+parser (node-aligned ``extract_mentions`` / ``resolve_mentions``), and the
+flat-text/resource flattener.
+"""
+
+from .comment import CommentEvent, CommentOperator, normalize_comment
+from .dedup import DedupStore, InMemoryDedupStore, make_event_key, make_message_key
+from .flatten import flatten
+from .mentions import (
+    MentionExtraction,
+    extract_mentions,
+    is_mention_all,
+    parse_at_tags,
+    resolve_mentions,
+)
+from .pipeline import InboundPipeline
+from .registry import parse_message_content
+
+__all__ = [
+    "CommentEvent",
+    "CommentOperator",
+    "DedupStore",
+    "InMemoryDedupStore",
+    "InboundPipeline",
+    "MentionExtraction",
+    "extract_mentions",
+    "flatten",
+    "is_mention_all",
+    "make_event_key",
+    "make_message_key",
+    "normalize_comment",
+    "parse_at_tags",
+    "parse_message_content",
+    "resolve_mentions",
+]
diff --git a/lark_channel/channel/normalize/comment.py b/lark_channel/channel/normalize/comment.py
new file mode 100644
index 0000000..f4f9423
--- /dev/null
+++ b/lark_channel/channel/normalize/comment.py
@@ -0,0 +1,147 @@
+"""Normalize ``drive.notice.comment_add_v1`` events.
+
+Wire payload (verified against the live Feishu tenant API)::
+
+    {
+      "file_token": "...",
+      "file_type": "docx",
+      "comment_id": "...",
+      "reply_id": "...",
+      "is_mentioned": true,
+      "create_time": "1700000000000",   # ms, string
+      "notice_meta": {
+        "from_user_id":  { "open_id": "...", "user_id": "...", "union_id": "..." },
+        "to_user_id":    { ... },
+        "file_token": "...",
+        "file_type": "docx",
+        "timestamp": "1700000000000",
+        "is_mentioned": true,
+        "notice_type": "comment_add"
+      },
+      // Legacy fallbacks (older p1 callbacks):
+      "user_id":   { "open_id": "...", ... },
+      "is_mention": true,
+      "action_time": "1700000000000"
+    }
+
+The operator lives at ``notice_meta.from_user_id`` (top-level
+``user_id`` is the legacy fallback). Whether the bot was mentioned is a
+boolean flag (``is_mentioned``), not a probe of the mentions array.
+"""
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class CommentOperator:
+    open_id: Optional[str] = None
+    user_id: Optional[str] = None
+    union_id: Optional[str] = None
+
+
+@dataclass
+class CommentEvent:
+    file_token: str
+    file_type: str
+    comment_id: str
+    reply_id: Optional[str]
+    operator: CommentOperator
+    mentioned_bot: bool
+    timestamp: int
+    raw: Dict[str, Any] = field(default_factory=dict)
+
+
+def normalize_comment(
+    data: Any,
+    *,
+    bot_open_id: Optional[str] = None,
+    envelope_timestamp: Optional[str] = None,
+) -> Optional[CommentEvent]:
+    """Flatten the raw ``drive.notice.comment_add_v1`` payload.
+
+    Accepts either the whole envelope (with ``event`` key) or the inner
+    event dict. Returns ``None`` when the payload is malformed or missing
+    one of the required fields (``file_token`` / ``file_type`` /
+    ``comment_id`` / operator open_id).
+
+    ``envelope_timestamp`` is the ``header.create_time`` (p2) or top-level
+    ``ts`` (p1) carried by the WS/HTTP envelope. The inner event payload
+    omits a per-event timestamp on the wire, so the envelope is the only
+    reliable source — pass it from the dispatcher callback.
+
+    ``bot_open_id`` is unused — the bot-mention signal is sourced from the
+    payload's ``is_mentioned`` flag instead. The parameter is kept for
+    backward compatibility with the previous (broken) implementation.
+    """
+    if not isinstance(data, dict):
+        data = _try_dict(data)
+        if data is None:
+            return None
+    event = data.get("event") if isinstance(data.get("event"), dict) else data
+    if not isinstance(event, dict):
+        return None
+    notice_meta = event.get("notice_meta") if isinstance(event.get("notice_meta"), dict) else {}
+
+    file_token = event.get("file_token") or notice_meta.get("file_token") or ""
+    file_type = event.get("file_type") or notice_meta.get("file_type") or ""
+    comment_id = event.get("comment_id") or notice_meta.get("comment_id") or ""
+
+    # Operator: prefer notice_meta.from_user_id (current p2 wire format),
+    # fall back to top-level user_id (legacy p1 callback shape). The old
+    # path looked at ``event.operator`` / ``event.operator_id`` — neither
+    # is in the actual payload, so operator came back null.
+    user_id_obj = notice_meta.get("from_user_id") or event.get("user_id") or {}
+    if not isinstance(user_id_obj, dict):
+        user_id_obj = {}
+    operator_open_id = user_id_obj.get("open_id")
+
+    # Required-field gate (node-aligned). Missing operator open_id is a
+    # malformed payload — drop rather than deliver a half-populated event.
+    if not (file_token and file_type and comment_id and operator_open_id):
+        return None
+
+    reply_id = event.get("reply_id") or notice_meta.get("reply_id") or None
+
+    op = CommentOperator(
+        open_id=operator_open_id,
+        user_id=user_id_obj.get("user_id"),
+        union_id=user_id_obj.get("union_id"),
+    )
+
+    mentioned_bot_flag = bool(
+        event.get("is_mentioned")
+        if event.get("is_mentioned") is not None
+        else (notice_meta.get("is_mentioned") or event.get("is_mention"))
+    )
+
+    ts_str = (
+        event.get("create_time")
+        or notice_meta.get("timestamp")
+        or event.get("action_time")
+        or event.get("event_create_time")
+        or event.get("timestamp")
+        or envelope_timestamp
+    )
+    try:
+        ts = int(ts_str) if ts_str is not None else 0
+    except (TypeError, ValueError):
+        ts = 0
+
+    return CommentEvent(
+        file_token=file_token,
+        file_type=file_type,
+        comment_id=comment_id,
+        reply_id=reply_id,
+        operator=op,
+        mentioned_bot=mentioned_bot_flag,
+        timestamp=ts,
+        raw=event,
+    )
+
+
+def _try_dict(obj) -> Optional[Dict[str, Any]]:
+    try:
+        return {k: getattr(obj, k) for k in dir(obj) if not k.startswith("_")}
+    except Exception:  # pragma: no cover
+        return None
diff --git a/lark_channel/channel/normalize/converters/__init__.py b/lark_channel/channel/normalize/converters/__init__.py
new file mode 100644
index 0000000..aa0516b
--- /dev/null
+++ b/lark_channel/channel/normalize/converters/__init__.py
@@ -0,0 +1,85 @@
+"""Per-type MessageContent → (content_text, resources) converters.
+
+Each converter is a pure function ``convert(content) -> (str, List[ResourceDescriptor])``.
+The ``REGISTRY`` maps concrete content types to their converter. The top-level
+:func:`lark_channel.channel.normalize.flatten.flatten` dispatches via this table
+and falls back to :mod:`.fallback` for unknown variants.
+
+Layout mirrors node-sdk's ``channel/normalize/converters/*.ts``.
+"""
+
+from typing import Any, Callable, Dict, List, Tuple
+
+from ...types import (
+    AudioContent,
+    CalendarContent,
+    FileContent,
+    FolderContent,
+    GeneralCalendarContent,
+    HongbaoContent,
+    ImageContent,
+    InteractiveContent,
+    LocationContent,
+    MediaContent,
+    MergeForwardContent,
+    PostContent,
+    ResourceDescriptor,
+    ShareCalendarEventContent,
+    ShareChatContent,
+    ShareUserContent,
+    StickerContent,
+    SystemContent,
+    TextContent,
+    TodoContent,
+    VideoChatContent,
+    VoteContent,
+)
+from . import (
+    audio,
+    calendar,
+    fallback,
+    file,
+    folder,
+    hongbao,
+    image,
+    interactive,
+    location,
+    merge_forward,
+    post,
+    share,
+    sticker,
+    system,
+    text,
+    todo,
+    video,
+    video_chat,
+    vote,
+)
+
+Converter = Callable[[Any], Tuple[str, List[ResourceDescriptor]]]
+
+REGISTRY: Dict[type, Converter] = {
+    TextContent: text.convert,
+    PostContent: post.convert,
+    ImageContent: image.convert,
+    FileContent: file.convert,
+    AudioContent: audio.convert,
+    MediaContent: video.convert,
+    StickerContent: sticker.convert,
+    InteractiveContent: interactive.convert,
+    ShareChatContent: share.convert_chat,
+    ShareUserContent: share.convert_user,
+    SystemContent: system.convert,
+    LocationContent: location.convert,
+    FolderContent: folder.convert,
+    HongbaoContent: hongbao.convert,
+    VideoChatContent: video_chat.convert,
+    CalendarContent: calendar.convert,
+    GeneralCalendarContent: calendar.convert_general,
+    ShareCalendarEventContent: calendar.convert_share_event,
+    VoteContent: vote.convert,
+    TodoContent: todo.convert,
+    MergeForwardContent: merge_forward.convert,
+}
+
+__all__ = ["REGISTRY", "Converter", "fallback"]
diff --git a/lark_channel/channel/normalize/converters/_utils.py b/lark_channel/channel/normalize/converters/_utils.py
new file mode 100644
index 0000000..b9d5c1a
--- /dev/null
+++ b/lark_channel/channel/normalize/converters/_utils.py
@@ -0,0 +1,60 @@
+"""Shared helpers used across per-type converters."""
+
+import datetime
+from typing import Any
+
+
+def attr(s: Any) -> str:
+    """Escape a string for use inside an XML-like attribute value."""
+    return (s or "").replace('"', "'").replace("\n", " ")
+
+
+def format_duration(ms: Any) -> str:
+    """Format a millisecond duration as ``12s`` / ``1.5s``."""
+    try:
+        if not ms:
+            return "0s"
+        s = ms / 1000.0
+        formatted = f"{s:.1f}"
+        if "." in formatted:
+            return formatted.rstrip("0").rstrip(".") + "s"
+        return f"{int(s)}s"
+    except Exception:  # pragma: no cover
+        return "0s"
+
+
+def rfc3339_beijing(create_time_ms: Any) -> str:
+    """Format a timestamp as ``YYYY-MM-DDTHH:MM:SS+08:00`` (best-effort)."""
+    if not create_time_ms:
+        return ""
+    try:
+        ts = int(create_time_ms)
+        if ts > 10**12:
+            ts = ts / 1000.0
+        dt = datetime.datetime.fromtimestamp(
+            ts, tz=datetime.timezone(datetime.timedelta(hours=8))
+        )
+        return dt.strftime("%Y-%m-%dT%H:%M:%S+08:00")
+    except Exception:  # pragma: no cover
+        return ""
+
+
+def millis_to_datetime(value: Any) -> str:
+    """Format a ms-or-s epoch timestamp as ``YYYY-MM-DD HH:MM:SS``.
+
+    Mirrors node-sdk's ``millisToDatetime`` helper used by calendar / video_chat
+    / todo converters. Accepts str-or-int input; returns empty string on any
+    parse failure so converters can conditionally omit a line.
+    """
+    if value in (None, "", 0, "0"):
+        return ""
+    try:
+        ts = int(value)
+        if ts > 10**12:
+            ts = ts / 1000.0
+        dt = datetime.datetime.fromtimestamp(
+            ts, tz=datetime.timezone(datetime.timedelta(hours=8))
+        )
+        return dt.strftime("%Y-%m-%d %H:%M:%S")
+    except Exception:  # pragma: no cover
+        return ""
diff --git a/lark_channel/channel/normalize/converters/audio.py b/lark_channel/channel/normalize/converters/audio.py
new file mode 100644
index 0000000..a4caad4
--- /dev/null
+++ b/lark_channel/channel/normalize/converters/audio.py
@@ -0,0 +1,17 @@
+"""Converter: AudioContent → ``<audio .../>`` + resource."""
+
+from typing import List, Tuple
+
+from ...types import AudioContent, ResourceDescriptor
+from ._utils import format_duration
+
+
+def convert(content: AudioContent) -> Tuple[str, List[ResourceDescriptor]]:
+    key = content.file_key
+    dur = format_duration(content.duration_ms)
+    if not key:
+        return "[audio]", []
+    return (
+        f'<audio key="{key}" duration="{dur}"/>',
+        [ResourceDescriptor(type="audio", file_key=key, duration_ms=content.duration_ms)],
+    )
diff --git a/lark_channel/channel/normalize/converters/calendar.py b/lark_channel/channel/normalize/converters/calendar.py
new file mode 100644
index 0000000..4aeb5ec
--- /dev/null
+++ b/lark_channel/channel/normalize/converters/calendar.py
@@ -0,0 +1,52 @@
+"""Converters: Calendar variants → ``<tag>...</tag>`` blocks.
+
+Aligned with node-sdk's ``converters/calendar.ts``. Three variants share the
+same inner formatting (📅 summary + 🕙 start ~ end) but use distinct wrapping
+tags:
+
+- :class:`CalendarContent`              → ``<calendar_invite>``
+- :class:`GeneralCalendarContent`       → ``<calendar>``
+- :class:`ShareCalendarEventContent`    → ``<calendar_share>``
+"""
+
+from typing import List, Tuple
+
+from ...types import (
+    CalendarContent,
+    GeneralCalendarContent,
+    ResourceDescriptor,
+    ShareCalendarEventContent,
+)
+from ._utils import millis_to_datetime
+
+
+def _format_inner(summary: str, start_time, end_time) -> str:
+    lines: List[str] = []
+    if summary:
+        lines.append(f"📅 {summary}")
+    start = millis_to_datetime(start_time)
+    end = millis_to_datetime(end_time)
+    if start and end:
+        lines.append(f"🕙 {start} ~ {end}")
+    elif start:
+        lines.append(f"🕙 {start}")
+    return "\n".join(lines) if lines else "[calendar event]"
+
+
+def convert(content: CalendarContent) -> Tuple[str, List[ResourceDescriptor]]:
+    inner = _format_inner(content.summary, content.start_time, content.end_time)
+    return f"<calendar_invite>\n{inner}\n</calendar_invite>", []
+
+
+def convert_general(
+    content: GeneralCalendarContent,
+) -> Tuple[str, List[ResourceDescriptor]]:
+    inner = _format_inner(content.summary, content.start_time, content.end_time)
+    return f"<calendar>\n{inner}\n</calendar>", []
+
+
+def convert_share_event(
+    content: ShareCalendarEventContent,
+) -> Tuple[str, List[ResourceDescriptor]]:
+    inner = _format_inner(content.summary, content.start_time, content.end_time)
+    return f"<calendar_share>\n{inner}\n</calendar_share>", []
diff --git a/lark_channel/channel/normalize/converters/fallback.py b/lark_channel/channel/normalize/converters/fallback.py
new file mode 100644
index 0000000..3a2ffa3
--- /dev/null
+++ b/lark_channel/channel/normalize/converters/fallback.py
@@ -0,0 +1,13 @@
+"""Converter: UnknownContent / anything unrecognised → placeholder text."""
+
+from typing import Any, List, Tuple
+
+from ...types import ResourceDescriptor, UnknownContent
+
+
+def convert(content: Any) -> Tuple[str, List[ResourceDescriptor]]:
+    if isinstance(content, UnknownContent):
+        raw = content.raw
+        text = raw.get("text") if isinstance(raw, dict) else None
+        return text or "[unsupported message]", []
+    return "[unsupported message]", []
diff --git a/lark_channel/channel/normalize/converters/file.py b/lark_channel/channel/normalize/converters/file.py
new file mode 100644
index 0000000..0e31491
--- /dev/null
+++ b/lark_channel/channel/normalize/converters/file.py
@@ -0,0 +1,17 @@
+"""Converter: FileContent → ``<file .../>`` + resource."""
+
+from typing import List, Tuple
+
+from ...types import FileContent, ResourceDescriptor
+from ._utils import attr
+
+
+def convert(content: FileContent) -> Tuple[str, List[ResourceDescriptor]]:
+    key = content.file_key
+    name = content.file_name or ""
+    if not key:
+        return "[file]", []
+    return (
+        f'<file key="{key}" name="{attr(name)}"/>',
+        [ResourceDescriptor(type="file", file_key=key, file_name=content.file_name)],
+    )
diff --git a/lark_channel/channel/normalize/converters/folder.py b/lark_channel/channel/normalize/converters/folder.py
new file mode 100644
index 0000000..afc62b2
--- /dev/null
+++ b/lark_channel/channel/normalize/converters/folder.py
@@ -0,0 +1,23 @@
+"""Converter: FolderContent → ``<folder key="..." name="..."/>``.
+
+Aligned with node-sdk's ``converters/folder.ts``: ``key`` is the primary
+identifier (the file_key on the wire), ``name`` is optional.
+
+When ``file_key`` is missing, emits ``[folder]`` placeholder to match node.
+"""
+
+from typing import List, Tuple
+
+from ...types import FolderContent, ResourceDescriptor
+from ._utils import attr
+
+
+def convert(content: FolderContent) -> Tuple[str, List[ResourceDescriptor]]:
+    if not content.file_key:
+        return "[folder]", []
+    if content.file_name:
+        return (
+            f'<folder key="{content.file_key}" name="{attr(content.file_name)}"/>',
+            [],
+        )
+    return f'<folder key="{content.file_key}"/>', []
diff --git a/lark_channel/channel/normalize/converters/hongbao.py b/lark_channel/channel/normalize/converters/hongbao.py
new file mode 100644
index 0000000..03829cd
--- /dev/null
+++ b/lark_channel/channel/normalize/converters/hongbao.py
@@ -0,0 +1,10 @@
+"""Converter: HongbaoContent → ``<hongbao .../>``."""
+
+from typing import List, Tuple
+
+from ...types import HongbaoContent, ResourceDescriptor
+from ._utils import attr
+
+
+def convert(content: HongbaoContent) -> Tuple[str, List[ResourceDescriptor]]:
+    return f'<hongbao text="{attr(content.text)}"/>', []
diff --git a/lark_channel/channel/normalize/converters/image.py b/lark_channel/channel/normalize/converters/image.py
new file mode 100644
index 0000000..1eab0a4
--- /dev/null
+++ b/lark_channel/channel/normalize/converters/image.py
@@ -0,0 +1,12 @@
+"""Converter: ImageContent → ``![image](image_key)`` + resource."""
+
+from typing import List, Tuple
+
+from ...types import ImageContent, ResourceDescriptor
+
+
+def convert(content: ImageContent) -> Tuple[str, List[ResourceDescriptor]]:
+    key = content.image_key
+    if not key:
+        return "[image]", []
+    return f"![image]({key})", [ResourceDescriptor(type="image", file_key=key)]
diff --git a/lark_channel/channel/normalize/converters/interactive.py b/lark_channel/channel/normalize/converters/interactive.py
new file mode 100644
index 0000000..ed0a2bb
--- /dev/null
+++ b/lark_channel/channel/normalize/converters/interactive.py
@@ -0,0 +1,62 @@
+"""Converter: InteractiveContent — deep-walk a CardKit v2 card.
+
+Concatenates markdown / plain-text leaves in traversal order, deduping
+adjacent duplicates. Unknown widgets are skipped.
+"""
+
+from typing import Any, Dict, List, Tuple
+
+from ...types import InteractiveContent, ResourceDescriptor
+
+
+def convert(content: InteractiveContent) -> Tuple[str, List[ResourceDescriptor]]:
+    return _walk(content.card), []
+
+
+def _walk(card: Dict[str, Any]) -> str:
+    if not isinstance(card, dict):
+        return "[interactive]"
+    seen: List[str] = []
+
+    def visit_iterative(root: Any) -> None:
+        stack: List[Any] = [root]
+        while stack:
+            node = stack.pop()
+            if isinstance(node, dict):
+                tag = node.get("tag")
+                if tag == "markdown":
+                    c = node.get("content")
+                    if c:
+                        seen.append(str(c))
+                    continue
+                if tag == "plain_text":
+                    c = node.get("content")
+                    if c:
+                        seen.append(str(c))
+                    continue
+                children = []
+                if tag == "div":
+                    text = node.get("text")
+                    if isinstance(text, dict):
+                        children.append(text)
+                children.extend(node.values())
+                stack.extend(reversed(children))
+            elif isinstance(node, list):
+                stack.extend(reversed(node))
+
+    header = card.get("header") or {}
+    if isinstance(header, dict):
+        visit_iterative(header.get("title"))
+        visit_iterative(header.get("subtitle"))
+    body = card.get("body") or {}
+    visit_iterative(body)
+
+    deduped: List[str] = []
+    for s in seen:
+        s = s.strip()
+        if not s:
+            continue
+        if deduped and deduped[-1] == s:
+            continue
+        deduped.append(s)
+    return "\n".join(deduped) or "[interactive]"
diff --git a/lark_channel/channel/normalize/converters/location.py b/lark_channel/channel/normalize/converters/location.py
new file mode 100644
index 0000000..9881382
--- /dev/null
+++ b/lark_channel/channel/normalize/converters/location.py
@@ -0,0 +1,14 @@
+"""Converter: LocationContent → ``<location .../>``."""
+
+from typing import List, Tuple
+
+from ...types import LocationContent, ResourceDescriptor
+from ._utils import attr
+
+
+def convert(content: LocationContent) -> Tuple[str, List[ResourceDescriptor]]:
+    text = (
+        f'<location name="{attr(content.name)}" '
+        f'lng="{content.longitude or ""}" lat="{content.latitude or ""}"/>'
+    )
+    return text, []
diff --git a/lark_channel/channel/normalize/converters/merge_forward.py b/lark_channel/channel/normalize/converters/merge_forward.py
new file mode 100644
index 0000000..eb13278
--- /dev/null
+++ b/lark_channel/channel/normalize/converters/merge_forward.py
@@ -0,0 +1,142 @@
+"""Converter: MergeForwardContent → ``<forwarded_messages>`` wrapper.
+
+Aligned with node-sdk's ``converters/merge-forward.ts``:
+
+- Each item is rendered as ``[timestamp] sender:\\n<4-space-indented body>``.
+- The whole inner body (including any nested ``<forwarded_messages>`` block)
+  is indented 4 spaces relative to its header. Nested forwards thus step in
+  by another 4 spaces at each depth, without the *header* itself being
+  indented at depth 0.
+- Empty or loading payloads emit ``<forwarded_messages/>`` (self-closing).
+- Truncation footer: ``\\n... (truncated)`` (no indent).
+
+Indentation follows node's ``indentLines(content, '    ')`` helper — i.e.
+indent the rendered inner text, NOT the header.
+"""
+
+from typing import Dict, List, Set, Tuple
+
+from ...types import MergeForwardContent, ResourceDescriptor
+from ._utils import rfc3339_beijing
+
+
+def convert(content: MergeForwardContent) -> Tuple[str, List[ResourceDescriptor]]:
+    return _flatten(content), _collect_resources(content)
+
+
+def _flatten(content: MergeForwardContent) -> str:
+    return _flatten_iterative(content)
+
+
+def _flatten_single(
+    content: MergeForwardContent,
+    rendered_children: Dict[int, str],
+) -> str:
+    if content.loading or not content.items:
+        return "<forwarded_messages/>"
+
+    parts: List[str] = []
+    for item in content.items:
+        # Per-item error isolation — node's ``try { renderItem } catch { skip }``
+        # (see node's merge-forward.ts ``formatSubTree`` loop).
+        try:
+            sender = item.sender_name or item.sender_open_id or "unknown"
+            ts = rfc3339_beijing(item.create_time) or "unknown"
+            inner_text = ""
+            if item.content is not None:
+                if isinstance(item.content, MergeForwardContent):
+                    inner_text = rendered_children.get(
+                        id(item.content),
+                        "<forwarded_messages/>",
+                    )
+                else:
+                    # Import late to avoid cycles — flatten dispatches via the registry.
+                    from ..flatten import flatten
+
+                    txt, _ = flatten(item.content)
+                    inner_text = txt
+            indented = _indent(inner_text, "    ")
+            parts.append(
+                f"[{ts}] {sender}:\n{indented}" if indented else f"[{ts}] {sender}:"
+            )
+        except Exception:  # pragma: no cover - defensive
+            continue
+
+    if not parts:
+        return "<forwarded_messages/>"
+
+    body = "\n".join(parts)
+    footer = ""
+    if content.truncated:
+        footer += "\n... (truncated)"
+    if content.error:
+        footer += f"\n[error: {content.error}]"
+    return f"<forwarded_messages>\n{body}{footer}\n</forwarded_messages>"
+
+
+def _flatten_iterative(content: MergeForwardContent) -> str:
+    rendered: Dict[int, str] = {}
+    visiting: Set[int] = set()
+    stack: List[Tuple[MergeForwardContent, bool]] = [(content, False)]
+    while stack:
+        node, expanded = stack.pop()
+        node_id = id(node)
+        if expanded:
+            rendered[node_id] = _flatten_single(node, rendered)
+            visiting.discard(node_id)
+            continue
+        if node_id in rendered:
+            continue
+        if node_id in visiting:
+            rendered[node_id] = "<forwarded_messages/>"
+            continue
+        visiting.add(node_id)
+        stack.append((node, True))
+        for item in reversed(node.items or []):
+            try:
+                child = item.content
+                if isinstance(child, MergeForwardContent) and id(child) not in rendered:
+                    stack.append((child, False))
+            except Exception:  # pragma: no cover - defensive
+                continue
+    return rendered.get(id(content), "<forwarded_messages/>")
+
+
+def _indent(text: str, prefix: str) -> str:
+    if not text:
+        return ""
+    return "\n".join(f"{prefix}{line}" for line in text.splitlines())
+
+
+def _collect_resources(content: MergeForwardContent) -> List[ResourceDescriptor]:
+    out: List[ResourceDescriptor] = []
+    seen_forwards: Set[int] = set()
+    stack = [iter(content.items or [])]
+    seen_forwards.add(id(content))
+    while stack:
+        try:
+            item = next(stack[-1])
+        except StopIteration:
+            stack.pop()
+            continue
+
+        # Per-item error isolation — keeps resource collection resilient to
+        # one malformed child (mirrors the converter's skip-bad-item policy).
+        try:
+            child = item.content
+            if child is None:
+                continue
+            if isinstance(child, MergeForwardContent):
+                child_id = id(child)
+                if child_id in seen_forwards:
+                    continue
+                seen_forwards.add(child_id)
+                stack.append(iter(child.items or []))
+            else:
+                from ..flatten import flatten
+
+                _, res = flatten(child)
+                out.extend(res)
+        except Exception:  # pragma: no cover - defensive
+            continue
+    return out
diff --git a/lark_channel/channel/normalize/converters/post.py b/lark_channel/channel/normalize/converters/post.py
new file mode 100644
index 0000000..153bc7c
--- /dev/null
+++ b/lark_channel/channel/normalize/converters/post.py
@@ -0,0 +1,107 @@
+"""Converter: PostContent → Markdown (headings / bold / italic / code / links)."""
+
+from typing import Any, Dict, List, Tuple
+
+from ...types import PostContent, ResourceDescriptor
+
+
+def convert(content: PostContent) -> Tuple[str, List[ResourceDescriptor]]:
+    md = _post_to_markdown(content.post) if content.post else content.text
+    resources = _post_resources(content.post) if content.post else []
+    return md, resources
+
+
+def _iter_documents(post: Dict[str, Any]) -> List[Dict[str, Any]]:
+    if not isinstance(post, dict) or not post:
+        return []
+    if "content" in post:
+        return [post]
+    return [doc for doc in post.values() if isinstance(doc, dict)]
+
+
+def _post_to_markdown(post: Dict[str, Any]) -> str:
+    docs = _iter_documents(post)
+    if not docs:
+        return ""
+    locale = docs[0]
+    lines: List[str] = []
+    title = locale.get("title")
+    if title:
+        lines.append(f"# {title}")
+    for para in locale.get("content") or []:
+        chunks: List[str] = []
+        for el in para or []:
+            if not isinstance(el, dict):
+                continue
+            tag = el.get("tag")
+            if tag == "text":
+                t = el.get("text") or ""
+                styles = el.get("style") or []
+                if "bold" in styles:
+                    t = f"**{t}**"
+                if "italic" in styles:
+                    t = f"*{t}*"
+                if "code" in styles:
+                    t = f"`{t}`"
+                if "strikethrough" in styles:
+                    t = f"~~{t}~~"
+                chunks.append(t)
+            elif tag == "a":
+                chunks.append(f"[{el.get('text') or ''}]({el.get('href') or ''})")
+            elif tag == "at":
+                nm = el.get("user_name") or el.get("user_id") or ""
+                chunks.append(f"@{nm}")
+            elif tag == "emotion":
+                chunks.append(f":{el.get('emoji_type') or ''}:")
+            elif tag == "img":
+                chunks.append(f"![image]({el.get('image_key') or ''})")
+            elif tag == "media":
+                chunks.append(f"[media:{el.get('file_key') or ''}]")
+            elif tag == "code_block":
+                lang = (el.get("language") or "").lower()
+                text = el.get("text") or ""
+                chunks.append(f"```{lang}\n{text}\n```")
+            elif tag == "hr":
+                chunks.append("---")
+            elif tag == "md":
+                chunks.append(el.get("text") or "")
+        line = "".join(chunks)
+        if line:
+            lines.append(line)
+    return "\n\n".join(lines).strip()
+
+
+def _post_resources(post: Dict[str, Any]) -> List[ResourceDescriptor]:
+    resources: List[ResourceDescriptor] = []
+    seen = set()
+
+    def add(kind: str, key: Any, *, file_name: Any = None) -> None:
+        if not isinstance(key, str) or not key:
+            return
+        dedup_key = (kind, key)
+        if dedup_key in seen:
+            return
+        seen.add(dedup_key)
+        resources.append(
+            ResourceDescriptor(
+                type=kind,  # type: ignore[arg-type]
+                file_key=key,
+                file_name=file_name if isinstance(file_name, str) and file_name else None,
+            )
+        )
+
+    for doc in _iter_documents(post):
+        for para in doc.get("content") or []:
+            for el in para or []:
+                if not isinstance(el, dict):
+                    continue
+                tag = el.get("tag")
+                if tag == "img":
+                    add("image", el.get("image_key"))
+                elif tag == "media":
+                    add("video", el.get("file_key"))
+                elif tag == "audio":
+                    add("audio", el.get("file_key"))
+                elif tag == "file":
+                    add("file", el.get("file_key"), file_name=el.get("file_name"))
+    return resources
diff --git a/lark_channel/channel/normalize/converters/share.py b/lark_channel/channel/normalize/converters/share.py
new file mode 100644
index 0000000..2a43481
--- /dev/null
+++ b/lark_channel/channel/normalize/converters/share.py
@@ -0,0 +1,18 @@
+"""Converters: ShareChatContent / ShareUserContent → card placeholders.
+
+Aligned with node-sdk's ``converters/share.ts``: both use ``id="..."`` as the
+attribute (not ``chat_id`` / ``user_id``).
+"""
+
+from typing import List, Tuple
+
+from ...types import ResourceDescriptor, ShareChatContent, ShareUserContent
+from ._utils import attr
+
+
+def convert_chat(content: ShareChatContent) -> Tuple[str, List[ResourceDescriptor]]:
+    return f'<group_card id="{attr(content.chat_id)}"/>', []
+
+
+def convert_user(content: ShareUserContent) -> Tuple[str, List[ResourceDescriptor]]:
+    return f'<contact_card id="{attr(content.user_id)}"/>', []
diff --git a/lark_channel/channel/normalize/converters/sticker.py b/lark_channel/channel/normalize/converters/sticker.py
new file mode 100644
index 0000000..60348f8
--- /dev/null
+++ b/lark_channel/channel/normalize/converters/sticker.py
@@ -0,0 +1,15 @@
+"""Converter: StickerContent → ``<sticker .../>`` + resource."""
+
+from typing import List, Tuple
+
+from ...types import ResourceDescriptor, StickerContent
+
+
+def convert(content: StickerContent) -> Tuple[str, List[ResourceDescriptor]]:
+    key = content.file_key
+    if not key:
+        return "[sticker]", []
+    return (
+        f'<sticker key="{key}"/>',
+        [ResourceDescriptor(type="sticker", file_key=key)],
+    )
diff --git a/lark_channel/channel/normalize/converters/system.py b/lark_channel/channel/normalize/converters/system.py
new file mode 100644
index 0000000..c359f3f
--- /dev/null
+++ b/lark_channel/channel/normalize/converters/system.py
@@ -0,0 +1,47 @@
+"""Converter: SystemContent → human-readable text via template expansion.
+
+Lark system messages ship a template string with ``{var}`` placeholders
+(e.g. ``"{from_user} invited {to_chatters}"``) plus a dict of values. We
+expand the placeholders here so downstream consumers see
+the rendered human text rather than the template.
+"""
+
+import re
+from typing import List, Tuple
+
+from ...types import ResourceDescriptor, SystemContent
+
+_VAR_RE = re.compile(r"\{([a-z_]+)\}")
+
+
+def convert(content: SystemContent) -> Tuple[str, List[ResourceDescriptor]]:
+    template = content.template or ""
+    if not template:
+        return "[system message]", []
+
+    raw = content.raw if isinstance(content.raw, dict) else {}
+
+    def _replace(match: "re.Match[str]") -> str:
+        name = match.group(1)
+        val = raw.get(name)
+        if isinstance(val, list):
+            return ", ".join(_display(v) for v in val)
+        if isinstance(val, str):
+            return val
+        if val is None:
+            return ""
+        return match.group(0)
+
+    out = _VAR_RE.sub(_replace, template).strip()
+    return out or "[system message]", []
+
+
+def _display(v) -> str:
+    """Best-effort stringify for a list element in a system message template.
+
+    Lark ships from_user / to_chatters as lists of ``{id, name}`` dicts; we
+    prefer the display name, then the id, then the raw repr.
+    """
+    if isinstance(v, dict):
+        return v.get("name") or v.get("open_id") or v.get("id") or ""
+    return str(v)
diff --git a/lark_channel/channel/normalize/converters/text.py b/lark_channel/channel/normalize/converters/text.py
new file mode 100644
index 0000000..577063f
--- /dev/null
+++ b/lark_channel/channel/normalize/converters/text.py
@@ -0,0 +1,9 @@
+"""Converter: TextContent → plain string."""
+
+from typing import List, Tuple
+
+from ...types import ResourceDescriptor, TextContent
+
+
+def convert(content: TextContent) -> Tuple[str, List[ResourceDescriptor]]:
+    return content.text, []
diff --git a/lark_channel/channel/normalize/converters/todo.py b/lark_channel/channel/normalize/converters/todo.py
new file mode 100644
index 0000000..a72fd06
--- /dev/null
+++ b/lark_channel/channel/normalize/converters/todo.py
@@ -0,0 +1,25 @@
+"""Converter: TodoContent → ``<todo>...</todo>`` block.
+
+Aligned with node-sdk's ``converters/todo.ts``: emits title + body + due-time
+lines wrapped in ``<todo>``. Falls back to ``<todo>\\n[todo]\\n</todo>`` if
+none of the three fields are present.
+"""
+
+from typing import List, Tuple
+
+from ...types import ResourceDescriptor, TodoContent
+from ._utils import millis_to_datetime
+
+
+def convert(content: TodoContent) -> Tuple[str, List[ResourceDescriptor]]:
+    lines: List[str] = []
+    if content.title:
+        lines.append(content.title)
+    if content.body:
+        lines.append(content.body)
+    due = millis_to_datetime(content.due_time)
+    if due:
+        lines.append(f"Due: {due}")
+    if not lines:
+        return "<todo>\n[todo]\n</todo>", []
+    return "<todo>\n" + "\n".join(lines) + "\n</todo>", []
diff --git a/lark_channel/channel/normalize/converters/video.py b/lark_channel/channel/normalize/converters/video.py
new file mode 100644
index 0000000..c4b3a88
--- /dev/null
+++ b/lark_channel/channel/normalize/converters/video.py
@@ -0,0 +1,27 @@
+"""Converter: MediaContent (video) → ``<video .../>`` + resource."""
+
+from typing import List, Tuple
+
+from ...types import MediaContent, ResourceDescriptor
+from ._utils import attr, format_duration
+
+
+def convert(content: MediaContent) -> Tuple[str, List[ResourceDescriptor]]:
+    key = content.file_key
+    cover = content.image_key
+    dur = format_duration(content.duration_ms)
+    name = content.file_name or ""
+    if not key:
+        return "[video]", []
+    return (
+        f'<video key="{key}" name="{attr(name)}" duration="{dur}"/>',
+        [
+            ResourceDescriptor(
+                type="video",
+                file_key=key,
+                file_name=content.file_name,
+                duration_ms=content.duration_ms,
+                cover_image_key=cover,
+            )
+        ],
+    )
diff --git a/lark_channel/channel/normalize/converters/video_chat.py b/lark_channel/channel/normalize/converters/video_chat.py
new file mode 100644
index 0000000..405ec06
--- /dev/null
+++ b/lark_channel/channel/normalize/converters/video_chat.py
@@ -0,0 +1,22 @@
+"""Converter: VideoChatContent → ``<meeting>...</meeting>`` block.
+
+Aligned with node-sdk's ``converters/video-chat.ts``: emits a multi-line
+``<meeting>`` block with 📹 topic + 🕙 start-time (if present), or the
+fallback ``[video chat]`` placeholder.
+"""
+
+from typing import List, Tuple
+
+from ...types import ResourceDescriptor, VideoChatContent
+from ._utils import millis_to_datetime
+
+
+def convert(content: VideoChatContent) -> Tuple[str, List[ResourceDescriptor]]:
+    lines: List[str] = []
+    if content.topic:
+        lines.append(f"📹 {content.topic}")
+    start = millis_to_datetime(content.start_time)
+    if start:
+        lines.append(f"🕙 {start}")
+    inner = "\n".join(lines) if lines else "[video chat]"
+    return f"<meeting>\n{inner}\n</meeting>", []
diff --git a/lark_channel/channel/normalize/converters/vote.py b/lark_channel/channel/normalize/converters/vote.py
new file mode 100644
index 0000000..b594102
--- /dev/null
+++ b/lark_channel/channel/normalize/converters/vote.py
@@ -0,0 +1,20 @@
+"""Converter: VoteContent → ``<vote>...</vote>`` block.
+
+Aligned with node-sdk's ``converters/vote.ts``: emits the topic on its own
+line, then each option prefixed with ``• `` (bullet), wrapped in ``<vote>``.
+"""
+
+from typing import List, Tuple
+
+from ...types import ResourceDescriptor, VoteContent
+
+
+def convert(content: VoteContent) -> Tuple[str, List[ResourceDescriptor]]:
+    if not content.topic and not content.options:
+        return "<vote>\n[vote]\n</vote>", []
+    lines: List[str] = []
+    if content.topic:
+        lines.append(content.topic)
+    for opt in content.options or []:
+        lines.append(f"• {opt}")
+    return "<vote>\n" + "\n".join(lines) + "\n</vote>", []
diff --git a/lark_channel/channel/normalize/dedup.py b/lark_channel/channel/normalize/dedup.py
new file mode 100644
index 0000000..fb90d44
--- /dev/null
+++ b/lark_channel/channel/normalize/dedup.py
@@ -0,0 +1,125 @@
+"""Pipeline-layer event de-duplication with pluggable storage.
+
+Two-key dedup: ``(account_id, event_id)`` catches Webhook retries;
+``(account_id, message_id)`` also catches WS reconnect backfill where the
+event ID changes but the message does not.
+
+Two-layer dedup architecture
+============================
+
+The Channel SDK dedups at two distinct layers, and consumers MUST understand
+which layer they are extending:
+
++----------------------+------------------+------------------------+--------------------------+
+| Layer                | Protocol         | Constructor parameter  | Trigger point            |
++======================+==================+========================+==========================+
+| Pipeline ``Deduper`` | ``DedupStore``   | ``dedup_store=`` (ctor)| ``InboundPipeline``      |
+|                      | (this module)    |                        | entry — webhook retries  |
+|                      |                  |                        | + WS reconnect backfill  |
++----------------------+------------------+------------------------+--------------------------+
+| Safety ``SeenCache`` | ``ICache``       | ``safety_cache=``      | ``SafetyPipeline.push_*``|
+|                      | (lark_channel.core) | (ctor)                 | — pre-dispatch dedup     |
++----------------------+------------------+------------------------+--------------------------+
+
+Both default to in-memory implementations when not supplied. They are
+**different protocols** with different methods — this is intentional, not
+redundancy. See ``docs/dedup-architecture.md`` for the long-form
+explainer including reference implementations.
+
+Frozen contract
+===============
+
+The ``DedupStore`` Protocol below — method names, signatures, and semantics
+— is **frozen** for the SDK 1.x line. Any change is treated as a breaking
+release. Custom implementations written today will keep working without
+modification.
+"""
+
+import threading
+import time
+from collections import OrderedDict
+from typing import Optional, Protocol, runtime_checkable
+
+
+@runtime_checkable
+class DedupStore(Protocol):
+    def seen(self, key: str) -> bool: ...
+    def mark(self, key: str, ttl_seconds: int) -> None: ...
+
+
+class InMemoryDedupStore:
+    """Thread-safe bounded TTL cache; LRU eviction on overflow."""
+
+    def __init__(self, max_entries: int = 5000):
+        self._max = max_entries
+        self._data: "OrderedDict[str, float]" = OrderedDict()
+        self._lock = threading.Lock()
+
+    def seen(self, key: str) -> bool:
+        with self._lock:
+            exp = self._data.get(key)
+            if exp is None:
+                return False
+            if exp <= time.time():
+                self._data.pop(key, None)
+                return False
+            # touch for LRU ordering
+            self._data.move_to_end(key)
+            return True
+
+    def mark(self, key: str, ttl_seconds: int) -> None:
+        with self._lock:
+            self._data[key] = time.time() + ttl_seconds
+            self._data.move_to_end(key)
+            self._evict_locked()
+
+    def _evict_locked(self) -> None:
+        now = time.time()
+        # Drop expired entries first (cheap when we overflow)
+        while self._data and len(self._data) > self._max:
+            # Evict oldest by insertion order.
+            k, exp = next(iter(self._data.items()))
+            self._data.pop(k, None)
+        # Periodic expiry sweep (best-effort)
+        if len(self._data) % 64 == 0:
+            expired = [k for k, exp in self._data.items() if exp <= now]
+            for k in expired:
+                self._data.pop(k, None)
+
+    def size(self) -> int:
+        return len(self._data)
+
+
+def make_event_key(account_id: str, event_id: str) -> str:
+    return f"evt:{account_id}:{event_id}"
+
+
+def make_message_key(account_id: str, message_id: str) -> str:
+    return f"msg:{account_id}:{message_id}"
+
+
+class Deduper:
+    """Wrapper that combines a DedupStore with the two-key strategy."""
+
+    def __init__(self, store: Optional[DedupStore], ttl_seconds: int, enabled: bool = True):
+        self._store = store
+        self._ttl = ttl_seconds
+        self._enabled = enabled and store is not None
+
+    def check_and_mark(self, account_id: str, event_id: Optional[str], message_id: Optional[str]) -> bool:
+        """Return True if the event should be processed (not a duplicate)."""
+        if not self._enabled or self._store is None:
+            return True
+        if event_id:
+            k1 = make_event_key(account_id, event_id)
+            if self._store.seen(k1):
+                return False
+        if message_id:
+            k2 = make_message_key(account_id, message_id)
+            if self._store.seen(k2):
+                return False
+        if event_id:
+            self._store.mark(make_event_key(account_id, event_id), self._ttl)
+        if message_id:
+            self._store.mark(make_message_key(account_id, message_id), self._ttl)
+        return True
diff --git a/lark_channel/channel/normalize/flatten.py b/lark_channel/channel/normalize/flatten.py
new file mode 100644
index 0000000..e0c2142
--- /dev/null
+++ b/lark_channel/channel/normalize/flatten.py
@@ -0,0 +1,20 @@
+"""Flatten a :class:`MessageContent` union into ``(content_text, resources)``.
+
+Dispatches to per-type converters in :mod:`.converters`. Layout mirrors
+node-sdk's ``channel/normalize/converters/*.ts`` + ``registry.ts`` pair; new
+message types are added by dropping a file into ``converters/`` and
+registering it in ``converters/__init__.py`` — no changes here.
+"""
+
+from typing import List, Tuple
+
+from ..types import MessageContent, ResourceDescriptor
+from .converters import REGISTRY, fallback
+
+
+def flatten(content: MessageContent) -> Tuple[str, List[ResourceDescriptor]]:
+    """Return ``(content_text, resources)`` for a ``MessageContent`` variant."""
+    converter = REGISTRY.get(type(content))
+    if converter is not None:
+        return converter(content)
+    return fallback.convert(content)
diff --git a/lark_channel/channel/normalize/interactive.py b/lark_channel/channel/normalize/interactive.py
new file mode 100644
index 0000000..9fd4bed
--- /dev/null
+++ b/lark_channel/channel/normalize/interactive.py
@@ -0,0 +1,80 @@
+"""Interactive (card) message re-fetch + v1/v2 normalization.
+
+The event payload for `msg_type=interactive` is truncated. If the caller opts
+in (default), we re-fetch the full card JSON with `GET /im/v1/messages/:id`
+and detect the CardKit version.
+"""
+
+import inspect
+import json
+from typing import Any, Dict, Optional
+
+from lark_channel.core.log import logger
+
+from ..types import InteractiveContent
+
+
+def _detect_version(card: Dict[str, Any]) -> str:
+    if not isinstance(card, dict):
+        return "unknown"
+    if "schema" in card or "body" in card:
+        return "v2"
+    if "elements" in card or "config" in card or "i18n_elements" in card:
+        return "v1"
+    if "card" in card:
+        return _detect_version(card.get("card") or {})
+    return "unknown"
+
+
+def _extract_card_json(payload: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """Pull the card JSON from a GET /messages/:id response.
+
+    The response wraps the message in `data.items[0].body.content`, which is
+    itself a JSON string for interactive messages.
+    """
+    if not isinstance(payload, dict):
+        return None
+    data = payload.get("data") or payload
+    items = data.get("items") if isinstance(data, dict) else None
+    if not items and isinstance(data, dict):
+        return _parse_body_content(data.get("body") or {})
+    if not isinstance(items, list) or not items:
+        return None
+    first = items[0]
+    if not isinstance(first, dict):
+        return None
+    return _parse_body_content(first.get("body") or {})
+
+
+def _parse_body_content(body: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    if not isinstance(body, dict):
+        return None
+    content = body.get("content")
+    if isinstance(content, dict):
+        return content
+    if isinstance(content, str):
+        try:
+            parsed = json.loads(content)
+            return parsed if isinstance(parsed, dict) else None
+        except ValueError:
+            return None
+    return None
+
+
+async def fetch_interactive(message_id: str, fetch_message) -> Optional[InteractiveContent]:
+    """Fetch full interactive card JSON for `message_id`.
+
+    `fetch_message(id) -> dict | awaitable[dict]` is injected so this module
+    stays testable without a real Lark client.
+    """
+    try:
+        result = fetch_message(message_id)
+        if inspect.isawaitable(result):
+            result = await result
+    except Exception as e:  # pragma: no cover - network/defensive
+        logger.warning("interactive fetch failed for %s: %s", message_id, e)
+        return None
+    card = _extract_card_json(result or {})
+    if card is None:
+        return None
+    return InteractiveContent(card=card, card_version=_detect_version(card), raw=card)
diff --git a/lark_channel/channel/normalize/mentions.py b/lark_channel/channel/normalize/mentions.py
new file mode 100644
index 0000000..73dde1a
--- /dev/null
+++ b/lark_channel/channel/normalize/mentions.py
@@ -0,0 +1,223 @@
+"""Parse Lark mention placeholders (node-aligned API).
+
+Mirrors node-sdk's ``channel/normalize/mentions.ts`` two-step flow:
+
+    ext = extract_mentions(raw, bot_open_id)   # parse + index
+    text = resolve_mentions(text, ext)         # second-pass replace
+
+:func:`is_mention_all` matches node's ``isMentionAll`` (detects by key
+``@_all`` or ``id.user_id == "all"``).
+
+``parse_at_tags`` is a Python-only helper for post / card payloads that
+inline ``<at user_id="...">Name</at>`` tags — node handles these inside its
+converter walk, so there's no direct counterpart.
+"""
+
+import re
+from dataclasses import dataclass, field
+from typing import Any, Dict, Iterable, List, Optional, Tuple
+
+from ..types import Mention
+
+_PLACEHOLDER_RE = re.compile(r"@_user_\d+")
+# Matches the ``@_all`` mention-all placeholder Feishu embeds in text content
+# for messages that mention everyone. Needs a non-word-char (or
+# end-of-string) boundary after ``@_all`` so we don't misfire on, say,
+# ``@_all_employees``.
+_AT_ALL_RE = re.compile(r"@_all(?![A-Za-z0-9_])")
+
+# Human-visible string substituted in place of the ``@_all`` placeholder
+# when resolving mentions. ``@all`` is the locale-neutral default; callers
+# wanting a localized rendering can monkey-patch this module attribute.
+MENTION_ALL_DISPLAY = "@all"
+_AT_TAG_RE = re.compile(
+    r"<at\s+([^>]*?)>(?P<name>.*?)</at>",
+    re.IGNORECASE | re.DOTALL,
+)
+_ATTR_RE = re.compile(r'([\w_-]+)\s*=\s*"([^"]*)"')
+
+
+def text_has_mention_all(text: Optional[str]) -> bool:
+    """True if ``text`` contains the ``@_all`` placeholder.
+
+    Feishu does NOT populate ``event.message.mentions`` for mention-all
+    messages in all cases — the only signal can be an ``@_all`` token
+    inside ``content.text``. Without detecting that, downstream policy
+    code sees ``mentioned_all=False`` and the ``mention_all_blocked``
+    gate never fires.
+    """
+    if not text:
+        return False
+    return _AT_ALL_RE.search(text) is not None
+
+
+# ---------------------------------------------------------------------------
+# Data shape
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class MentionExtraction:
+    """Indexed result of :func:`extract_mentions`.
+
+    Mirrors node's ``MentionExtraction`` interface.
+    """
+
+    mentions: Dict[str, Mention] = field(default_factory=dict)
+    """Keyed by placeholder (e.g. ``@_user_1``)."""
+
+    mentions_by_open_id: Dict[str, Mention] = field(default_factory=dict)
+    """Keyed by ``open_id`` (excludes @all)."""
+
+    mention_list: List[Mention] = field(default_factory=list)
+    """Filtered list: no @all, no bot self-mention."""
+
+    mentioned_all: bool = False
+    mentioned_bot: bool = False
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def is_mention_all(m: Any) -> bool:
+    """True if ``m`` represents an ``@all`` mention (node-aligned)."""
+    if isinstance(m, dict):
+        if m.get("key") == "@_all":
+            return True
+        ident = m.get("id")
+        if isinstance(ident, dict) and ident.get("user_id") == "all":
+            return True
+        return False
+    if getattr(m, "key", None) == "@_all":
+        return True
+    ident = getattr(m, "id", None)
+    return ident is not None and getattr(ident, "user_id", None) == "all"
+
+
+def _mention_from_event(m: Any) -> Mention:
+    if isinstance(m, dict):
+        ident = m.get("id") if isinstance(m.get("id"), dict) else {}
+        return Mention(
+            key=m.get("key") or "",
+            open_id=ident.get("open_id") if ident else None,
+            union_id=ident.get("union_id") if ident else None,
+            user_id=ident.get("user_id") if ident else None,
+            name=m.get("name"),
+            tenant_key=m.get("tenant_key"),
+        )
+    ident = getattr(m, "id", None)
+    return Mention(
+        key=getattr(m, "key", "") or "",
+        open_id=getattr(ident, "open_id", None) if ident is not None else None,
+        union_id=getattr(ident, "union_id", None) if ident is not None else None,
+        user_id=getattr(ident, "user_id", None) if ident is not None else None,
+        name=getattr(m, "name", None),
+        tenant_key=getattr(m, "tenant_key", None),
+    )
+
+
+# ---------------------------------------------------------------------------
+# Public API (node-aligned)
+# ---------------------------------------------------------------------------
+
+
+def extract_mentions(
+    raw: Optional[Iterable[Any]],
+    bot_open_id: Optional[str] = None,
+) -> MentionExtraction:
+    """Index raw event mentions into a :class:`MentionExtraction`.
+
+    - ``@all`` entries set ``mentioned_all`` and are excluded from lists.
+    - Entries whose ``open_id`` matches ``bot_open_id`` set ``mentioned_bot``
+      and are also excluded from ``mention_list`` (but kept in ``mentions``
+      by key so :func:`resolve_mentions` can still strip placeholders).
+    """
+    out = MentionExtraction()
+    for m in (raw or []):
+        if is_mention_all(m):
+            out.mentioned_all = True
+            continue
+        parsed = _mention_from_event(m)
+        if parsed.key:
+            out.mentions[parsed.key] = parsed
+        if parsed.open_id:
+            out.mentions_by_open_id[parsed.open_id] = parsed
+        if bot_open_id and parsed.open_id == bot_open_id:
+            out.mentioned_bot = True
+            continue
+        out.mention_list.append(parsed)
+    return out
+
+
+def resolve_mentions(
+    content: str,
+    ext: MentionExtraction,
+    *,
+    strip_bot_mentions: bool = False,
+    bot_open_id: Optional[str] = None,
+) -> str:
+    """Replace ``@_user_N`` placeholders with ``@{name}``.
+
+    When ``strip_bot_mentions=True`` and ``bot_open_id`` is provided,
+    placeholders referencing the bot are removed outright (adjacent
+    whitespace normalized).
+    """
+    if not content:
+        return content or ""
+
+    def _replace(match: "re.Match[str]") -> str:
+        key = match.group(0)
+        m = ext.mentions.get(key)
+        if m is None:
+            return key
+        if strip_bot_mentions and bot_open_id and m.open_id == bot_open_id:
+            return ""
+        if not m.name:
+            return key
+        return f"@{m.name}"
+
+    result = _PLACEHOLDER_RE.sub(_replace, content)
+    # Rewrite ``@_all`` placeholder to the human-visible form; without this
+    # user-visible content carries the raw token.
+    result = _AT_ALL_RE.sub(MENTION_ALL_DISPLAY, result)
+    if strip_bot_mentions:
+        result = re.sub(r"\s{2,}", " ", result).strip()
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Python-only helper: inline <at> tags inside post / card rendered content
+# ---------------------------------------------------------------------------
+
+
+def parse_at_tags(text: str) -> Tuple[List[Mention], bool, str]:
+    """Strip ``<at user_id="ou_xxx">Name</at>`` tags into mentions + text.
+
+    Used for post / card rendered payloads where placeholders are unavailable.
+    No direct node counterpart — node handles this inside per-converter walks.
+    """
+    mentions: List[Mention] = []
+    mentioned_all = False
+
+    def _replace(match: "re.Match[str]") -> str:
+        nonlocal mentioned_all
+        attrs = dict(_ATTR_RE.findall(match.group(1)))
+        uid = attrs.get("user_id") or attrs.get("open_id") or ""
+        name = match.group("name") or attrs.get("user_name") or ""
+        if uid == "all":
+            mentioned_all = True
+            return MENTION_ALL_DISPLAY
+        mentions.append(
+            Mention(
+                key=f"@_at_{uid}",
+                open_id=uid if uid.startswith("ou_") else None,
+                user_id=uid if not uid.startswith("ou_") else None,
+                name=name or None,
+            )
+        )
+        return f"@{name}" if name else f"@{uid}"
+
+    stripped = _AT_TAG_RE.sub(_replace, text)
+    return mentions, mentioned_all, stripped
diff --git a/lark_channel/channel/normalize/merge_forward.py b/lark_channel/channel/normalize/merge_forward.py
new file mode 100644
index 0000000..d96f071
--- /dev/null
+++ b/lark_channel/channel/normalize/merge_forward.py
@@ -0,0 +1,243 @@
+"""Merge-forward async expansion — single fetch, local traversal.
+
+Pattern:
+
+1. ONE top-level ``fetchSubMessages(messageId)`` call returns the flat list
+   of ALL descendants (including deeply-nested merge_forwards).
+2. Build a ``parent_id → [children]`` map keyed by ``upper_message_id``.
+3. Traverse the tree locally. Nested merge_forward items just recurse into
+   the same map — **no additional API calls**.
+
+A naive implementation that re-fetches for each nested merge_forward
+multiplies API calls with nesting depth. This module instead matches
+node: single fetch, local traversal.
+
+Any failure is captured in the ``.error`` field of the MergeForwardContent —
+handlers never see an exception.
+"""
+
+from collections import defaultdict
+from typing import Any, Dict, List, Optional, Set
+
+from lark_channel.core.log import logger
+
+from ..types import (
+    MergeForwardContent,
+    MergeForwardItem,
+    MessageContent,
+    UnknownContent,
+)
+from .registry import parse_message_content
+
+
+class MergeForwardExpander:
+    """Expand a merge_forward message via a single API fetch + local traversal.
+
+    Dependencies are injected so this is easy to test:
+        - ``fetch_message(message_id) -> payload dict``: returns the full
+          response (expected to contain ``data.items`` — the flat tree).
+        - ``resolve_names(open_ids) -> dict[open_id, display_name]``: batch
+          name lookup.
+    """
+
+    def __init__(
+        self,
+        fetch_message,
+        resolve_names=None,
+        max_depth: int = 3,
+        max_items: int = 50,
+    ):
+        self._fetch_message = fetch_message
+        self._resolve_names = resolve_names
+        self._max_depth = max_depth
+        self._max_items = max_items
+
+    async def expand(self, message_id: str, depth: int = 0) -> MergeForwardContent:
+        """Fetch once, build map, materialize tree. Never re-fetches."""
+        content = MergeForwardContent(loading=False)
+        if depth > self._max_depth:
+            content.error = "max_depth_exceeded"
+            return content
+
+        try:
+            payload = await _maybe_await(self._fetch_message(message_id))
+        except Exception as e:  # pragma: no cover - network/defensive
+            logger.warning("merge_forward fetch failed for %s: %s", message_id, e)
+            content.error = f"fetch_failed: {e}"
+            return content
+
+        if not payload:
+            content.error = "empty_payload"
+            return content
+
+        items_raw = _extract_all_items(payload)
+        if not items_raw:
+            return content  # empty tree — loading=False, items=[]
+
+        children_map = _build_children_map(items_raw, root_id=message_id)
+
+        # One batch name-resolve call for every sender across the whole tree.
+        open_ids: Set[str] = set()
+        for item in items_raw:
+            oid = _get_sender_open_id(item)
+            if oid:
+                open_ids.add(oid)
+        name_map: Dict[str, str] = {}
+        if open_ids and self._resolve_names is not None:
+            try:
+                resolved = await _maybe_await(
+                    self._resolve_names(list(open_ids))
+                )
+                if isinstance(resolved, dict):
+                    name_map = {k: v for k, v in resolved.items() if v}
+            except Exception as e:  # pragma: no cover - defensive
+                logger.warning("merge_forward name resolution failed: %s", e)
+
+        materialized = self._materialize(
+            message_id, children_map, name_map, depth=depth
+        )
+        content.items = materialized.items
+        content.truncated = materialized.truncated
+        return content
+
+    def _materialize(
+        self,
+        parent_id: str,
+        children_map: Dict[str, List[Dict[str, Any]]],
+        name_map: Dict[str, str],
+        depth: int,
+    ) -> MergeForwardContent:
+        """Build one ``MergeForwardContent`` level from the pre-fetched map."""
+        result = MergeForwardContent(loading=False)
+        if depth > self._max_depth:
+            result.error = "max_depth_exceeded"
+            return result
+
+        children = children_map.get(parent_id, [])
+        if len(children) > self._max_items:
+            children = children[: self._max_items]
+            result.truncated = True
+
+        items: List[MergeForwardItem] = []
+        for item in children:
+            try:
+                items.append(
+                    self._materialize_item(
+                        item, children_map, name_map, depth
+                    )
+                )
+            except Exception as e:  # pragma: no cover - defensive
+                logger.warning("merge_forward materialize item failed: %s", e)
+                continue
+        result.items = items
+        return result
+
+    def _materialize_item(
+        self,
+        item: Dict[str, Any],
+        children_map: Dict[str, List[Dict[str, Any]]],
+        name_map: Dict[str, str],
+        depth: int,
+    ) -> MergeForwardItem:
+        mt = item.get("msg_type") or item.get("message_type") or ""
+        oid = _get_sender_open_id(item)
+        child_content: MessageContent
+        if mt == "merge_forward":
+            child_id = item.get("message_id") or ""
+            if child_id:
+                # Node-aligned: recurse into the SAME map (no new fetch).
+                child_content = self._materialize(
+                    child_id, children_map, name_map, depth + 1
+                )
+            else:
+                child_content = UnknownContent(message_type="merge_forward", raw=item)
+        else:
+            body = item.get("body") or item
+            raw_content = body.get("content") if isinstance(body, dict) else None
+            if raw_content is None:
+                raw_content = item.get("content")
+            child_content = parse_message_content(mt, raw_content)
+        return MergeForwardItem(
+            message_id=item.get("message_id") or "",
+            sender_open_id=oid,
+            sender_name=name_map.get(oid) if oid else None,
+            create_time=_as_int(item.get("create_time")),
+            content=child_content,
+            raw=item,
+        )
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _extract_all_items(payload: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """Return every item dict from the fetch payload — DO NOT filter by msg_type.
+
+    Node traverses the full flat list (including nested merge_forward items)
+    and uses ``upper_message_id`` to rebuild the tree; filtering here would
+    lose nested children.
+    """
+    if not isinstance(payload, dict):
+        return []
+    data = payload.get("data") or payload
+    if not isinstance(data, dict):
+        return []
+    items = data.get("items") or data.get("messages") or []
+    if not isinstance(items, list):
+        return []
+    return [i for i in items if isinstance(i, dict)]
+
+
+def _build_children_map(
+    items: List[Dict[str, Any]], root_id: str
+) -> Dict[str, List[Dict[str, Any]]]:
+    """Group items by ``upper_message_id`` (fall back to ``root_id``).
+
+    Skips the root item itself to match node's
+    ``if (it.message_id === rootId && !it.upper_message_id) continue`` guard.
+
+    Sorts each bucket by ``create_time`` ascending.
+    """
+    m: Dict[str, List[Dict[str, Any]]] = defaultdict(list)
+    for it in items:
+        mid = it.get("message_id")
+        upper = it.get("upper_message_id")
+        if mid == root_id and not upper:
+            continue  # root itself
+        parent = upper or root_id
+        m[parent].append(it)
+    for arr in m.values():
+        arr.sort(key=lambda x: _as_int(x.get("create_time")) or 0)
+    return dict(m)
+
+
+def _get_sender_open_id(item: Dict[str, Any]) -> Optional[str]:
+    sender = item.get("sender") or {}
+    if isinstance(sender, dict):
+        return (
+            sender.get("id")
+            or sender.get("open_id")
+            or (sender.get("sender_id") or {}).get("open_id")
+            if isinstance(sender.get("sender_id"), dict)
+            else sender.get("id") or sender.get("open_id")
+        )
+    return None
+
+
+def _as_int(v: Any) -> Optional[int]:
+    if v is None:
+        return None
+    try:
+        return int(v)
+    except (TypeError, ValueError):
+        return None
+
+
+async def _maybe_await(v):
+    import inspect
+
+    if inspect.isawaitable(v):
+        return await v
+    return v
diff --git a/lark_channel/channel/normalize/pipeline.py b/lark_channel/channel/normalize/pipeline.py
new file mode 100644
index 0000000..a5949fe
--- /dev/null
+++ b/lark_channel/channel/normalize/pipeline.py
@@ -0,0 +1,326 @@
+"""Top-level inbound pipeline.
+
+Orchestrates the flow:
+    raw event → dedup → parse → async enrich (merge_forward, interactive,
+    mentions, identity) → InboundMessage.
+"""
+
+import inspect
+import html
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, List, Optional
+
+from lark_channel.core.log import logger
+
+from ..config import InboundConfig, SecurityConfig
+from ..types import (
+    Conversation,
+    Identity,
+    InboundMessage,
+    InteractiveContent,
+    Mention,
+    MergeForwardContent,
+    PostContent,
+    ReplyRef,
+    TextContent,
+)
+from .dedup import Deduper
+from .flatten import flatten
+from .interactive import fetch_interactive
+from .mentions import (
+    extract_mentions,
+    parse_at_tags,
+    resolve_mentions,
+    text_has_mention_all,
+)
+from .merge_forward import MergeForwardExpander
+from .registry import parse_message_content
+
+
+@dataclass
+class PipelineDeps:
+    """External hooks the pipeline needs (all optional for testing)."""
+
+    fetch_message: Optional[Callable[[str], Any]] = None
+    resolve_names: Optional[Callable[[List[str]], Any]] = None
+    resolve_identity: Optional[Callable[[str], Any]] = None
+
+
+@dataclass
+class PipelineConfig:
+    inbound: InboundConfig = field(default_factory=InboundConfig)
+    security: SecurityConfig = field(default_factory=SecurityConfig)
+    account_id: str = ""
+
+
+def _to_chat_type(value: Optional[str]) -> str:
+    if value in ("p2p", "group", "topic"):
+        return value
+    # Feishu sometimes uses "public"/"private" for chat_type.
+    if value == "private":
+        return "p2p"
+    if value == "public":
+        return "group"
+    return "unknown"
+
+
+def _sender_to_identity(sender: Any) -> Identity:
+    """Normalize an event.sender payload (dict or EventSender) to Identity."""
+    if isinstance(sender, dict):
+        sid = sender.get("sender_id") or {}
+        return Identity(
+            open_id=sid.get("open_id") or "",
+            union_id=sid.get("union_id"),
+            user_id=sid.get("user_id"),
+            is_bot=_is_bot_sender_type(sender.get("sender_type")),
+        )
+    sid = getattr(sender, "sender_id", None)
+    return Identity(
+        open_id=getattr(sid, "open_id", "") or "",
+        union_id=getattr(sid, "union_id", None),
+        user_id=getattr(sid, "user_id", None),
+        is_bot=_is_bot_sender_type(getattr(sender, "sender_type", None)),
+    )
+
+
+def _is_bot_sender_type(sender_type: Any) -> bool:
+    return sender_type in {"bot", "app"}
+
+
+def _message_to_dict(msg: Any) -> Dict[str, Any]:
+    if isinstance(msg, dict):
+        return msg
+    out: Dict[str, Any] = {}
+    for field_name in (
+        "message_id",
+        "root_id",
+        "parent_id",
+        "create_time",
+        "update_time",
+        "chat_id",
+        "thread_id",
+        "chat_type",
+        "message_type",
+        "content",
+        "mentions",
+        "user_agent",
+    ):
+        out[field_name] = getattr(msg, field_name, None)
+    return out
+
+
+class InboundPipeline:
+    def __init__(
+        self,
+        cfg: PipelineConfig,
+        deps: PipelineDeps,
+        deduper: Optional[Deduper] = None,
+    ) -> None:
+        self._cfg = cfg
+        self._deps = deps
+        self._deduper = deduper
+        self._bot_open_id: Optional[str] = None
+        self._chat_mode_resolver: Optional[Callable[[str], Any]] = None
+        self._expander = MergeForwardExpander(
+            fetch_message=deps.fetch_message,
+            resolve_names=deps.resolve_names,
+            max_depth=cfg.inbound.merge_forward_max_depth,
+            max_items=cfg.inbound.merge_forward_max_items,
+        )
+
+    def set_bot_open_id(self, open_id: Optional[str]) -> None:
+        self._bot_open_id = open_id or None
+
+    def set_chat_mode_resolver(self, resolver: Optional[Callable[[str], Any]]) -> None:
+        self._chat_mode_resolver = resolver
+
+    async def normalize(
+        self,
+        *,
+        message_event: Any,
+        sender: Any = None,
+        event_id: Optional[str] = None,
+    ) -> Optional[InboundMessage]:
+        return await self.process(
+            event_id=event_id,
+            message_event=message_event,
+            sender=sender,
+            apply_dedup=False,
+        )
+
+    async def process(
+        self,
+        event_id: Optional[str],
+        message_event: Any,
+        sender: Any,
+        *,
+        apply_dedup: bool = True,
+    ) -> Optional[InboundMessage]:
+        """Return InboundMessage or None if the event was deduped / filtered."""
+        msg = _message_to_dict(message_event)
+        message_id: str = msg.get("message_id") or ""
+
+        if apply_dedup and self._deduper is not None:
+            ok = self._deduper.check_and_mark(
+                self._cfg.account_id or "", event_id, message_id
+            )
+            if not ok:
+                logger.debug("inbound: dedup hit for %s / %s", event_id, message_id)
+                return None
+
+        message_type = msg.get("message_type") or ""
+        # Media capability gate (drop the message if that type is disabled)
+        media_caps = self._cfg.inbound.media_capabilities
+        gate_map = {
+            "image": media_caps.image,
+            "audio": media_caps.audio,
+            "media": media_caps.video,
+            "video": media_caps.video,
+            "file": media_caps.file,
+            "sticker": media_caps.sticker,
+        }
+        if message_type in gate_map and not gate_map[message_type]:
+            logger.debug("inbound: message_type %s disabled by media_caps", message_type)
+            return None
+
+        content = parse_message_content(message_type, msg.get("content"))
+
+        # Process mentions for text / post (extract → resolve).
+        raw_mentions = msg.get("mentions") or []
+        ext = extract_mentions(raw_mentions)
+        mentions: List[Mention] = list(ext.mention_list)
+        mentioned_all = ext.mentioned_all
+        if isinstance(content, TextContent):
+            # Feishu frequently ships ``@all`` messages with
+            # ``mentions = null`` — the only signal is an ``@_all``
+            # placeholder in ``content.text``. Without this probe the
+            # policy gate never sees ``mentioned_all=True`` so
+            # ``respond_to_mention_all`` / ``mention_all_blocked`` go
+            # silently skipped.
+            if not mentioned_all and text_has_mention_all(content.text):
+                mentioned_all = True
+            content.text = resolve_mentions(content.text, ext)
+        elif isinstance(content, PostContent):
+            if not mentioned_all and text_has_mention_all(content.text):
+                mentioned_all = True
+            content.text = resolve_mentions(content.text, ext)
+            at_mentions, at_all, stripped = parse_at_tags(content.text)
+            content.text = stripped
+            # Merge <at>-tag mentions in (dedup by open_id/user_id/key).
+            seen = {m.open_id or m.user_id or m.key for m in mentions}
+            for m in at_mentions:
+                sig = m.open_id or m.user_id or m.key
+                if sig in seen:
+                    continue
+                seen.add(sig)
+                mentions.append(m)
+            mentioned_all = mentioned_all or at_all
+
+        mentioned_bot = bool(
+            self._bot_open_id
+            and any(m.open_id == self._bot_open_id for m in mentions)
+        )
+
+        # Async enrichment: merge_forward expansion
+        if (
+            isinstance(content, MergeForwardContent)
+            and self._cfg.inbound.expand_merge_forward
+            and self._deps.fetch_message is not None
+            and message_id
+        ):
+            content = await self._expander.expand(message_id)
+
+        # Async enrichment: interactive card re-fetch
+        if (
+            isinstance(content, InteractiveContent)
+            and self._cfg.inbound.fetch_interactive_card
+            and self._deps.fetch_message is not None
+            and message_id
+        ):
+            fetched = await fetch_interactive(message_id, self._deps.fetch_message)
+            if fetched is not None:
+                # keep raw from the original event
+                fetched.raw = content.raw or fetched.raw
+                content = fetched
+
+        # Build conversation + reply ref
+        conversation = Conversation(
+            chat_id=msg.get("chat_id") or "",
+            chat_type=_to_chat_type(msg.get("chat_type")),
+            thread_id=msg.get("thread_id") or None,
+        )
+
+        chat_mode = None
+        if (
+            self._cfg.inbound.inject_chat_mode
+            and self._chat_mode_resolver is not None
+            and conversation.chat_id
+        ):
+            try:
+                chat_mode = self._chat_mode_resolver(conversation.chat_id)
+                if inspect.isawaitable(chat_mode):
+                    chat_mode = await chat_mode
+            except Exception as e:  # pragma: no cover - defensive
+                logger.debug("inbound: resolve chat mode failed: %s", e)
+                chat_mode = None
+
+        reply: Optional[ReplyRef] = None
+        parent_id = msg.get("parent_id") or ""
+        root_id = msg.get("root_id") or ""
+        if parent_id and parent_id != root_id:
+            reply = ReplyRef(message_id=parent_id)
+
+        sender_identity = _sender_to_identity(sender)
+        # Fill sender display name from name cache / resolver if available.
+        if not sender_identity.display_name and self._deps.resolve_names and sender_identity.open_id:
+            try:
+                result = self._deps.resolve_names([sender_identity.open_id])
+                if inspect.isawaitable(result):
+                    result = await result
+                if isinstance(result, dict):
+                    sender_identity.display_name = result.get(sender_identity.open_id) or sender_identity.display_name
+            except Exception as e:  # pragma: no cover - defensive
+                logger.debug("inbound: resolve sender name failed: %s", e)
+
+        # Flat-string + resource-descriptor views of `content`. Re-flatten
+        # every time in case merge_forward expansion or interactive re-fetch
+        # changed the content kind since the initial parse.
+        flat_text, resources = flatten(content)
+
+        # Second pass: resolve any ``@_user_N`` placeholder still in the
+        # rendered text. This catches placeholders embedded in nested
+        # merge_forward child content (parsed but not yet resolved because
+        # flatten walks children sync without a ctx). Idempotent on text that
+        # contains no placeholders.
+        flat_text = resolve_mentions(flat_text, ext)
+        safe_flat_text = _safe_content_text(flat_text)
+        content_text = safe_flat_text if self._cfg.security.strict_content_text else flat_text
+
+        return InboundMessage(
+            id=message_id,
+            create_time=_int_or_zero(msg.get("create_time")),
+            conversation=conversation,
+            sender=sender_identity,
+            mentions=mentions,
+            mentioned_all=mentioned_all,
+            reply=reply,
+            content=content,
+            raw=msg if self._cfg.inbound.include_raw and isinstance(msg, dict) else {},
+            content_text=content_text,
+            safe_content_text=safe_flat_text,
+            resources=resources,
+            mentioned_bot=mentioned_bot,
+            chat_mode=chat_mode,
+            raw_content_type=message_type,
+        )
+
+
+def _int_or_zero(v: Any) -> int:
+    try:
+        return int(v) if v is not None else 0
+    except (TypeError, ValueError):
+        return 0
+
+
+def _safe_content_text(value: str) -> str:
+    return html.escape(value or "", quote=True)
diff --git a/lark_channel/channel/normalize/registry.py b/lark_channel/channel/normalize/registry.py
new file mode 100644
index 0000000..938b31d
--- /dev/null
+++ b/lark_channel/channel/normalize/registry.py
@@ -0,0 +1,359 @@
+"""Convert Lark EventMessage.content JSON into a MessageContent variant.
+
+The Lark platform currently supports 19 message types. We produce a uniform
+`MessageContent` union so callers do not need to switch on the original
+wire schema.
+
+This module handles the SYNCHRONOUS parsing step only — async expansion
+(merge_forward child fetch, interactive card re-fetch) is layered on top in
+`pipeline.py`.
+"""
+
+import json
+from typing import Any, Dict, List, Optional, Tuple
+
+from lark_channel.core.log import logger
+
+from ..types import (
+    AudioContent,
+    CalendarContent,
+    FileContent,
+    FolderContent,
+    GeneralCalendarContent,
+    HongbaoContent,
+    ImageContent,
+    InteractiveContent,
+    LocationContent,
+    MediaContent,
+    MergeForwardContent,
+    MessageContent,
+    PostContent,
+    ShareCalendarEventContent,
+    ShareChatContent,
+    ShareUserContent,
+    StickerContent,
+    SystemContent,
+    TextContent,
+    TodoContent,
+    UnknownContent,
+    VideoChatContent,
+    VoteContent,
+)
+
+
+def _safe_json(raw: Any) -> Dict[str, Any]:
+    if isinstance(raw, dict):
+        return raw
+    if isinstance(raw, (bytes, bytearray)):
+        raw = raw.decode("utf-8", errors="replace")
+    if isinstance(raw, str) and raw:
+        try:
+            decoded = json.loads(raw)
+            if isinstance(decoded, dict):
+                return decoded
+        except (ValueError, TypeError) as e:  # pragma: no cover - defensive
+            logger.debug("parse_message_content: invalid JSON content: %s", e)
+    return {}
+
+
+def _flatten_post_text(post: Dict[str, Any]) -> Tuple[str, str]:
+    """Return (title, plain_text) from a post AST.
+
+    Post content has locale keys (`zh_cn`, `en_us`). We pick the first locale.
+    """
+    if not isinstance(post, dict):
+        return "", ""
+    first_key = next(iter(post), None)
+    if first_key is None:
+        return "", ""
+    locale_doc = post.get(first_key)
+    if not isinstance(locale_doc, dict):
+        return "", ""
+    title = locale_doc.get("title") or ""
+    lines: List[str] = []
+    for para in locale_doc.get("content") or []:
+        chunk: List[str] = []
+        for el in para or []:
+            if not isinstance(el, dict):
+                continue
+            tag = el.get("tag")
+            if tag == "text":
+                chunk.append(el.get("text") or "")
+            elif tag == "a":
+                chunk.append(el.get("text") or el.get("href") or "")
+            elif tag == "at":
+                nm = el.get("user_name") or el.get("user_id") or ""
+                chunk.append(f"@{nm}" if nm else "@")
+            elif tag == "emotion":
+                chunk.append(f":{el.get('emoji_type') or ''}:")
+            elif tag == "img":
+                chunk.append("[image]")
+            elif tag == "media":
+                chunk.append("[media]")
+            elif tag == "code_block":
+                chunk.append(el.get("text") or "")
+            elif tag == "hr":
+                chunk.append("---")
+            elif tag == "md":
+                chunk.append(el.get("text") or "")
+        lines.append("".join(chunk))
+    return title, "\n".join(lines)
+
+
+def _parse_text(data: Dict[str, Any]) -> TextContent:
+    return TextContent(text=data.get("text") or "", raw=data)
+
+
+def _parse_post(data: Dict[str, Any]) -> PostContent:
+    title, text = _flatten_post_text(data)
+    return PostContent(title=title, text=text, post=data, raw=data)
+
+
+def _parse_image(data: Dict[str, Any]) -> ImageContent:
+    return ImageContent(image_key=data.get("image_key") or "", raw=data)
+
+
+def _parse_file(data: Dict[str, Any]) -> FileContent:
+    return FileContent(
+        file_key=data.get("file_key") or "",
+        file_name=data.get("file_name"),
+        raw=data,
+    )
+
+
+def _parse_audio(data: Dict[str, Any]) -> AudioContent:
+    return AudioContent(
+        file_key=data.get("file_key") or "",
+        duration_ms=data.get("duration"),
+        raw=data,
+    )
+
+
+def _parse_media(data: Dict[str, Any]) -> MediaContent:
+    return MediaContent(
+        file_key=data.get("file_key") or "",
+        image_key=data.get("image_key"),
+        duration_ms=data.get("duration"),
+        file_name=data.get("file_name"),
+        raw=data,
+    )
+
+
+def _parse_sticker(data: Dict[str, Any]) -> StickerContent:
+    return StickerContent(file_key=data.get("file_key") or "", raw=data)
+
+
+def _parse_interactive(data: Dict[str, Any]) -> InteractiveContent:
+    """Build a minimal InteractiveContent from the event payload.
+
+    The event payload only contains truncated metadata — the pipeline will
+    decide whether to re-fetch the full card JSON via the API.
+    """
+    version = "unknown"
+    if isinstance(data, dict):
+        if "schema" in data or "header" in data or "body" in data:
+            version = "v2"
+        elif "card" in data or "config" in data or "elements" in data:
+            version = "v1"
+    return InteractiveContent(card=data, card_version=version, raw=data)
+
+
+def _parse_share_chat(data: Dict[str, Any]) -> ShareChatContent:
+    return ShareChatContent(chat_id=data.get("chat_id") or "", raw=data)
+
+
+def _parse_share_user(data: Dict[str, Any]) -> ShareUserContent:
+    return ShareUserContent(user_id=data.get("user_id") or "", raw=data)
+
+
+def _parse_system(data: Dict[str, Any]) -> SystemContent:
+    return SystemContent(
+        template=data.get("template") or "",
+        from_user=data.get("from_user") or [],
+        to_chatters=data.get("to_chatters") or [],
+        raw=data,
+    )
+
+
+def _parse_location(data: Dict[str, Any]) -> LocationContent:
+    def _f(v: Any) -> Optional[float]:
+        try:
+            return float(v) if v is not None else None
+        except (TypeError, ValueError):
+            return None
+
+    return LocationContent(
+        name=data.get("name") or "",
+        longitude=_f(data.get("longitude")),
+        latitude=_f(data.get("latitude")),
+        raw=data,
+    )
+
+
+def _parse_video_chat(data: Dict[str, Any]) -> VideoChatContent:
+    return VideoChatContent(
+        topic=data.get("topic") or "",
+        start_time=data.get("start_time"),
+        raw=data,
+    )
+
+
+def _parse_calendar(data: Dict[str, Any]) -> CalendarContent:
+    return CalendarContent(
+        summary=data.get("summary") or "",
+        start_time=data.get("start_time"),
+        end_time=data.get("end_time"),
+        raw=data,
+    )
+
+
+def _parse_vote(data: Dict[str, Any]) -> VoteContent:
+    return VoteContent(
+        topic=data.get("topic") or "",
+        options=list(data.get("options") or []),
+        raw=data,
+    )
+
+
+def _parse_todo(data: Dict[str, Any]) -> TodoContent:
+    """Todo's ``summary`` on the wire is ``{title, content: PostElement[][]}``.
+
+    We lift ``title`` + flat body text so downstream converters don't need to
+    re-walk the AST. Falls back to treating ``summary`` as a plain string if
+    the platform ever ships that shape.
+    """
+    summary = data.get("summary")
+    title = ""
+    body = ""
+    if isinstance(summary, dict):
+        title = summary.get("title") or ""
+        body = _extract_post_plain_text(summary.get("content"))
+    elif isinstance(summary, str):
+        title = summary
+    return TodoContent(
+        title=title,
+        body=body,
+        due_time=data.get("due_time"),
+        raw=data,
+    )
+
+
+def _extract_post_plain_text(blocks: Any) -> str:
+    """Flatten a post-AST ``PostElement[][]`` into plain text.
+
+    Mirrors node-sdk's ``extractPostPlainText``: keeps only ``text`` / ``a``
+    element text, joins elements within a paragraph with empty string, joins
+    paragraphs with newline.
+    """
+    if not isinstance(blocks, list):
+        return ""
+    lines: List[str] = []
+    for para in blocks:
+        if not isinstance(para, list):
+            continue
+        parts: List[str] = []
+        for el in para:
+            if not isinstance(el, dict):
+                continue
+            tag = el.get("tag")
+            text = el.get("text")
+            if tag in ("text", "a") and text:
+                parts.append(text)
+        if parts:
+            lines.append("".join(parts))
+    return "\n".join(lines)
+
+
+def _parse_merge_forward(data: Dict[str, Any]) -> MergeForwardContent:
+    """Build a loading=True merge_forward; pipeline is responsible for expansion."""
+    return MergeForwardContent(loading=True, raw=data)
+
+
+def _parse_folder(data: Dict[str, Any]) -> FolderContent:
+    return FolderContent(
+        file_key=data.get("file_key") or "",
+        file_name=data.get("file_name") or data.get("name") or "",
+        file_size=data.get("file_size"),
+        raw=data,
+    )
+
+
+def _parse_hongbao(data: Dict[str, Any]) -> HongbaoContent:
+    amount = data.get("amount")
+    try:
+        amount = int(amount) if amount is not None else None
+    except (TypeError, ValueError):
+        amount = None
+    return HongbaoContent(
+        text=data.get("text") or data.get("title") or "",
+        amount=amount,
+        raw=data,
+    )
+
+
+def _parse_general_calendar(data: Dict[str, Any]) -> GeneralCalendarContent:
+    return GeneralCalendarContent(
+        summary=data.get("summary") or data.get("title") or "",
+        start_time=data.get("start_time"),
+        end_time=data.get("end_time"),
+        raw=data,
+    )
+
+
+def _parse_share_calendar_event(data: Dict[str, Any]) -> ShareCalendarEventContent:
+    return ShareCalendarEventContent(
+        summary=data.get("summary") or "",
+        organizer=data.get("organizer_display_name") or data.get("organizer") or "",
+        start_time=data.get("start_time"),
+        end_time=data.get("end_time"),
+        raw=data,
+    )
+
+
+_PARSERS = {
+    "text": _parse_text,
+    "post": _parse_post,
+    "image": _parse_image,
+    "file": _parse_file,
+    "audio": _parse_audio,
+    # `media` and `video` share the same parser; the richer `MediaContent`
+    # dataclass carries the extra fields when they are present on the wire.
+    "media": _parse_media,
+    "video": _parse_media,
+    "sticker": _parse_sticker,
+    "interactive": _parse_interactive,
+    "share_chat": _parse_share_chat,
+    "share_user": _parse_share_user,
+    "system": _parse_system,
+    "location": _parse_location,
+    "folder": _parse_folder,
+    "hongbao": _parse_hongbao,
+    "video_chat": _parse_video_chat,
+    "calendar": _parse_calendar,
+    "general_calendar": _parse_general_calendar,
+    "share_calendar_event": _parse_share_calendar_event,
+    "vote": _parse_vote,
+    "todo": _parse_todo,
+    "merge_forward": _parse_merge_forward,
+}
+
+
+def parse_message_content(message_type: str, raw_content: Any) -> MessageContent:
+    """Synchronous first-pass parse.
+
+    - `message_type` drives the dispatch.
+    - `raw_content` is the string or dict from EventMessage.content.
+    - Unknown types fall back to `UnknownContent` — never raises.
+    """
+    data = _safe_json(raw_content)
+    parser = _PARSERS.get(message_type or "")
+    if parser is None:
+        return UnknownContent(message_type=message_type or "", raw=data)
+    try:
+        return parser(data)
+    except Exception as e:  # pragma: no cover - defensive
+        logger.exception("parse_message_content failed for %s: %s", message_type, e)
+        return UnknownContent(message_type=message_type or "", raw=data)
+
+
+SUPPORTED_MESSAGE_TYPES: Tuple[str, ...] = tuple(_PARSERS.keys())
diff --git a/lark_channel/channel/outbound/__init__.py b/lark_channel/channel/outbound/__init__.py
new file mode 100644
index 0000000..fe1fb99
--- /dev/null
+++ b/lark_channel/channel/outbound/__init__.py
@@ -0,0 +1,25 @@
+"""Outbound pipeline: convert OutboundMessage → Lark API calls.
+
+Sub-packages:
+    markdown/ — markdown → post-AST + code-fence-aware splitter
+    media/    — SSRF guard + zero-dep duration parsers + uploader
+    streaming/— streaming controllers + queue/throttle primitives
+"""
+
+from .markdown import markdown_to_post_ast, split_with_code_fences
+from .media import assert_public_url, parse_mp4_duration, parse_opus_duration
+from .retry import with_retry
+from .routing import infer_receive_id_type
+from .sender import OutboundSender, chunk_text
+
+__all__ = [
+    "OutboundSender",
+    "assert_public_url",
+    "chunk_text",
+    "infer_receive_id_type",
+    "markdown_to_post_ast",
+    "parse_mp4_duration",
+    "parse_opus_duration",
+    "split_with_code_fences",
+    "with_retry",
+]
diff --git a/lark_channel/channel/outbound/markdown/__init__.py b/lark_channel/channel/outbound/markdown/__init__.py
new file mode 100644
index 0000000..ef66c80
--- /dev/null
+++ b/lark_channel/channel/outbound/markdown/__init__.py
@@ -0,0 +1,9 @@
+"""Markdown → Lark post-AST conversion + code-fence-aware splitter."""
+
+from .splitter import split_with_code_fences
+from .to_post import markdown_to_post_ast
+
+__all__ = [
+    "markdown_to_post_ast",
+    "split_with_code_fences",
+]
diff --git a/lark_channel/channel/outbound/markdown/splitter.py b/lark_channel/channel/outbound/markdown/splitter.py
new file mode 100644
index 0000000..9c38f61
--- /dev/null
+++ b/lark_channel/channel/outbound/markdown/splitter.py
@@ -0,0 +1,68 @@
+"""Code-fence-aware markdown splitter.
+
+Aligned with node-sdk's ``channel/outbound/markdown/splitter.ts``. Splits a
+markdown string into chunks at most ``limit`` chars while preserving fenced
+code-block integrity across chunk boundaries.
+
+Plain-text line chunking used by :class:`OutboundSender` lives next to the
+sender itself (node-aligned — sender inlines chunking) and is not exposed
+here.
+"""
+
+import re
+from typing import List, Optional
+
+_FENCE_RE = re.compile(r"^```(\w*)\s*$")
+_HEADING_RE = re.compile(r"^#{1,6}\s")
+
+
+def split_with_code_fences(text: str, limit: int) -> List[str]:
+    """Markdown-aware splitter.
+
+    Guarantees:
+        - Each returned chunk is <= ``limit`` chars (bar a rare hard-overflow
+          when a single line exceeds the limit).
+        - Splits inside a fenced code block close with ``` and the next chunk
+          reopens with the same language tag.
+        - Prefers to break just *before* a heading line when the current
+          buffer is already ~75% full, so headings lead their chunk.
+    """
+    if len(text) <= limit:
+        return [text]
+    lines = text.split("\n")
+    out: List[str] = []
+    buf: List[str] = []
+    buf_len = 0
+    fence_lang: Optional[str] = None  # None when outside a fence
+
+    def flush():
+        nonlocal buf, buf_len
+        if not buf:
+            return
+        chunk = "\n".join(buf)
+        if fence_lang is not None:
+            chunk += "\n```"
+        out.append(chunk)
+        buf = []
+        buf_len = 0
+        if fence_lang is not None:
+            reopen = "```" + fence_lang
+            buf.append(reopen)
+            buf_len = len(reopen)
+
+    for line in lines:
+        m = _FENCE_RE.match(line)
+        line_len = len(line) + (1 if buf else 0)
+        is_heading = bool(_HEADING_RE.match(line))
+        near_full = buf_len > limit * 0.75
+
+        if buf_len + line_len > limit or (is_heading and near_full and buf):
+            flush()
+
+        buf.append(line)
+        buf_len += line_len
+        if m:
+            fence_lang = (m.group(1) or "") if fence_lang is None else None
+
+    flush()
+    return out
diff --git a/lark_channel/channel/outbound/markdown/to_post.py b/lark_channel/channel/outbound/markdown/to_post.py
new file mode 100644
index 0000000..f8f05ff
--- /dev/null
+++ b/lark_channel/channel/outbound/markdown/to_post.py
@@ -0,0 +1,370 @@
+"""Markdown → Lark post-AST converter.
+
+Covers the common subset: headings, bold, italic, inline code, code blocks,
+links, bullet / numbered lists, blockquotes, <at>, and horizontal rules.
+Unsupported syntax falls back to plain text, preserving readability.
+
+This is a pragmatic converter — not a full CommonMark parser — because the
+Lark post AST only supports a limited vocabulary. Lines that don't match a
+recognized pattern are emitted as single `text` runs with inline markers
+stripped.
+"""
+
+import re
+from typing import Any, Dict, List, Tuple
+
+from ...types import Identity
+
+# Inline marker patterns (order matters: most specific first).
+# Italic is tricky because `**bold**` also matches `*...*`. We require that
+# the italic delimiter is not adjacent to another `*` (or `_`).
+_INLINE_PATTERNS = [
+    (re.compile(r"\*\*(.+?)\*\*"), "bold"),
+    (re.compile(r"__(.+?)__"), "bold"),
+    (re.compile(r"(?<!\*)\*(?!\*)(?!\s)([^*\n]+?)(?<!\s)\*(?!\*)"), "italic"),
+    (re.compile(r"(?<!\w)(?<!_)_(?!_)(?!\s)([^_\n]+?)(?<!\s)_(?!_)(?!\w)"), "italic"),
+    (re.compile(r"`([^`\n]+)`"), "code"),
+    (re.compile(r"~~(.+?)~~"), "strikethrough"),
+]
+_LINK_RE = re.compile(r"\[([^\]]+)\]\(([^)]+)\)")
+_AT_RE = re.compile(r"<at\s+([^>]+)>([^<]*)</at>", re.IGNORECASE)
+_ATTR_RE = re.compile(r'([\w_-]+)\s*=\s*"([^"]*)"')
+
+
+def _parse_inline_runs(line: str) -> List[Dict[str, Any]]:
+    """Return list of text runs with style attributes for a single line."""
+    if not line:
+        return []
+
+    # Collect disjoint match ranges (bold / italic / code / link / at),
+    # non-overlapping, leftmost-first. Whatever is left is plain text.
+    matches: List[Tuple[int, int, Dict[str, Any]]] = []
+
+    for pat, style in _INLINE_PATTERNS:
+        for m in pat.finditer(line):
+            matches.append((m.start(), m.end(), {"tag": "text", "text": m.group(1), "style": [style]}))
+
+    for m in _LINK_RE.finditer(line):
+        matches.append((m.start(), m.end(), {"tag": "a", "text": m.group(1), "href": m.group(2)}))
+
+    for m in _AT_RE.finditer(line):
+        attrs = dict(_ATTR_RE.findall(m.group(1)))
+        uid = attrs.get("user_id") or attrs.get("open_id") or ""
+        name = m.group(2) or attrs.get("user_name") or uid
+        node: Dict[str, Any] = {"tag": "at"}
+        if uid:
+            node["user_id"] = uid
+        if name:
+            node["user_name"] = name
+        matches.append((m.start(), m.end(), node))
+
+    matches.sort(key=lambda t: (t[0], t[1]))
+    # Remove overlapping matches (keep the earliest; drop overlaps).
+    filtered: List[Tuple[int, int, Dict[str, Any]]] = []
+    cursor = 0
+    for s, e, node in matches:
+        if s < cursor:
+            continue
+        filtered.append((s, e, node))
+        cursor = e
+
+    # Interleave with plain-text runs.
+    out: List[Dict[str, Any]] = []
+    pos = 0
+    for s, e, node in filtered:
+        if s > pos:
+            out.append({"tag": "text", "text": line[pos:s]})
+        out.append(node)
+        pos = e
+    if pos < len(line):
+        out.append({"tag": "text", "text": line[pos:]})
+    return [r for r in out if r.get("text") or r.get("tag") == "at" or r.get("tag") == "a"]
+
+
+def _plain(text: str) -> List[Dict[str, Any]]:
+    return [{"tag": "text", "text": text}] if text else []
+
+
+def markdown_to_post_ast(
+    md: str,
+    title: str = "",
+    locale: str = "zh_cn",
+    mentions: "list[Identity] | None" = None,
+    table_mode: str = "off",
+    tag_md_mode: str = "structured",
+) -> Dict[str, Any]:
+    """Produce a Lark post AST (`{locale: {title, content: [[...]]}}`) from Markdown.
+
+    Mentions supplied via `mentions` are appended (inline @tags) to the first
+    paragraph so the recipient actually gets notified.
+
+    ``tag_md_mode``:
+        - ``"structured"`` (default): parse Markdown into explicit post nodes
+          (``tag:text`` with style attributes, ``tag:a`` for links,
+          ``tag:code_block`` for fenced code, etc). Cross-client deterministic.
+        - ``"native"``: wrap the raw markdown into one or more ``tag:md`` rows
+          (split at code-fence boundaries) and let the Feishu client's own
+          markdown parser render natively. Renders headers/blockquotes/lists
+          with native styling, but rendering depends on Feishu client version.
+    """
+    if tag_md_mode == "native":
+        return _build_native_md_ast(md, title=title, locale=locale, mentions=mentions)
+    lines = (md or "").splitlines()
+    paragraphs: List[List[Dict[str, Any]]] = []
+
+    i = 0
+    n = len(lines)
+
+    def _flush_paragraph(buf: List[str]) -> None:
+        if not buf:
+            return
+        para_text = "\n".join(buf).strip()
+        if not para_text:
+            return
+        paragraphs.append(_parse_inline_runs(para_text))
+        buf.clear()
+
+    buf: List[str] = []
+    while i < n:
+        line = lines[i]
+        stripped = line.strip()
+
+        # Horizontal rule
+        if re.fullmatch(r"-{3,}|\*{3,}|_{3,}", stripped or ""):
+            _flush_paragraph(buf)
+            paragraphs.append([{"tag": "hr"}])
+            i += 1
+            continue
+
+        # ATX heading #
+        m = re.match(r"^(#{1,6})\s+(.*)", line)
+        if m:
+            _flush_paragraph(buf)
+            heading_text = m.group(2).strip()
+            run = _parse_inline_runs(heading_text)
+            for r in run:
+                if r.get("tag") == "text":
+                    styles = r.setdefault("style", [])
+                    if "bold" not in styles:
+                        styles.append("bold")
+            paragraphs.append(run or _plain(heading_text))
+            i += 1
+            continue
+
+        # Fenced code block
+        m = re.match(r"^```(\w*)\s*$", line)
+        if m:
+            _flush_paragraph(buf)
+            lang = m.group(1) or ""
+            code_lines: List[str] = []
+            i += 1
+            while i < n and not re.match(r"^```\s*$", lines[i]):
+                code_lines.append(lines[i])
+                i += 1
+            if i < n:
+                i += 1  # skip closing fence
+            paragraphs.append(
+                [
+                    {
+                        "tag": "code_block",
+                        "language": lang.upper() if lang else "TEXT",
+                        "text": "\n".join(code_lines),
+                    }
+                ]
+            )
+            continue
+
+        # Blockquote
+        if stripped.startswith(">"):
+            _flush_paragraph(buf)
+            quote_lines: List[str] = []
+            while i < n and lines[i].lstrip().startswith(">"):
+                quote_lines.append(re.sub(r"^\s*>\s?", "", lines[i]))
+                i += 1
+            quote_text = "\n".join(quote_lines)
+            run = _parse_inline_runs(quote_text)
+            # Lark post has no native blockquote; prefix each line with │ so it's
+            # visually distinguishable.
+            paragraphs.append([{"tag": "text", "text": "│ "}] + run)
+            continue
+
+        # Bullet list / ordered list: emit each bullet as its own paragraph.
+        if re.match(r"^\s*[-*+]\s+", line) or re.match(r"^\s*\d+[.)]\s+", line):
+            _flush_paragraph(buf)
+            while i < n and (
+                re.match(r"^\s*[-*+]\s+", lines[i])
+                or re.match(r"^\s*\d+[.)]\s+", lines[i])
+            ):
+                item_line = lines[i]
+                bullet_text = re.sub(r"^\s*[-*+]\s+", "• ", item_line)
+                bullet_text = re.sub(r"^\s*\d+[.)]\s+", "\\g<0>", bullet_text)
+                paragraphs.append(_parse_inline_runs(bullet_text))
+                i += 1
+            continue
+
+        # Table: depend on table_mode setting.
+        if _looks_like_table_row(line):
+            _flush_paragraph(buf)
+            table_lines: List[str] = [line]
+            i += 1
+            while i < n and _looks_like_table_row(lines[i]):
+                table_lines.append(lines[i])
+                i += 1
+            converted = _convert_table(table_lines, mode=table_mode)
+            paragraphs.extend(converted)
+            continue
+
+        if not stripped:
+            _flush_paragraph(buf)
+            i += 1
+            continue
+
+        buf.append(line)
+        i += 1
+
+    _flush_paragraph(buf)
+
+    # Inject @mentions at the start of the first paragraph so recipients are
+    # notified.
+    if mentions and paragraphs:
+        at_runs: List[Dict[str, Any]] = []
+        for ident in mentions:
+            if not ident or not ident.open_id:
+                continue
+            at_runs.append(
+                {
+                    "tag": "at",
+                    "user_id": ident.open_id,
+                    "user_name": ident.display_name or "",
+                }
+            )
+            at_runs.append({"tag": "text", "text": " "})
+        paragraphs[0] = at_runs + paragraphs[0]
+
+    if not paragraphs:
+        paragraphs = [_plain("")]
+
+    return {locale: {"title": title or "", "content": paragraphs}}
+
+
+def _looks_like_table_row(line: str) -> bool:
+    stripped = (line or "").strip()
+    return stripped.count("|") >= 2 and stripped.startswith("|") and stripped.endswith("|")
+
+
+def _convert_table(lines: List[str], mode: str) -> List[List[Dict[str, Any]]]:
+    """Convert a Markdown table into paragraphs based on `mode`."""
+    if mode == "off":
+        return [_parse_inline_runs(ln) for ln in lines]
+
+    # Drop the separator row (---|---).
+    rows = [
+        [c.strip() for c in ln.strip().strip("|").split("|")]
+        for ln in lines
+        if not re.match(r"^\s*\|?[\s:\-|]+\|?\s*$", ln)
+    ]
+    if not rows:
+        return [_parse_inline_runs(ln) for ln in lines]
+
+    if mode == "bullets":
+        # "col1: val1 · col2: val2" per row, excluding the header row.
+        header = rows[0]
+        out: List[List[Dict[str, Any]]] = []
+        for row in rows[1:]:
+            pairs = [f"{header[i] if i < len(header) else ''}: {c}" for i, c in enumerate(row)]
+            out.append([{"tag": "text", "text": "• " + " · ".join(pairs)}])
+        return out or [_parse_inline_runs(lines[0])]
+
+    if mode == "code":
+        src = "\n".join(lines)
+        return [[{"tag": "code_block", "language": "TEXT", "text": src}]]
+
+    # mode == "table"
+    if mode == "table":
+        rendered = []
+        for row in rows:
+            rendered.append([{"tag": "text", "text": " | ".join(row)}])
+        return rendered
+
+    # default fallback
+    return [_parse_inline_runs(ln) for ln in lines]
+
+
+_FENCE_LINE_RE = re.compile(r"^```")
+
+
+def _build_native_md_ast(
+    md: str,
+    title: str = "",
+    locale: str = "zh_cn",
+    mentions: "list[Identity] | None" = None,
+) -> Dict[str, Any]:
+    """Pack raw markdown into one or more ``tag:md`` rows.
+
+    Each fenced code block is its own row; prose between fences is its own
+    row. This mirrors known Feishu client behavior (md content immediately
+    after a code fence may be swallowed otherwise).
+
+    Mentions are attached to the first row (consistent with structured mode).
+    """
+    segments = _split_at_code_fences(md or "")
+    rows: List[List[Dict[str, Any]]] = [
+        [{"tag": "md", "text": seg}] for seg in segments
+    ]
+
+    if mentions and rows:
+        at_runs: List[Dict[str, Any]] = []
+        for ident in mentions:
+            if not ident or not ident.open_id:
+                continue
+            at_runs.append({
+                "tag": "at",
+                "user_id": ident.open_id,
+                "user_name": ident.display_name or "",
+            })
+            at_runs.append({"tag": "text", "text": " "})
+        rows[0] = at_runs + rows[0]
+
+    return {locale: {"title": title or "", "content": rows}}
+
+
+def _split_at_code_fences(text: str) -> List[str]:
+    """Split markdown at fenced-code-block boundaries.
+
+    Returns a list of non-empty segments where each segment is either a
+    prose block (no fence lines) or one complete fenced code block
+    (open fence + body + close fence). Unclosed fences are absorbed into
+    the trailing segment as-is — no content is dropped.
+
+    Distinct from ``splitter.split_with_code_fences``: this one is
+    length-agnostic and never inserts synthetic close/reopen fences.
+    """
+    if not text:
+        return []
+    lines = text.split("\n")
+    out: List[str] = []
+    buf: List[str] = []
+    in_fence = False
+
+    def _flush():
+        if buf:
+            out.append("\n".join(buf))
+            buf.clear()
+
+    for line in lines:
+        is_fence = bool(_FENCE_LINE_RE.match(line))
+        if not in_fence and is_fence:
+            # Closing prose, opening fence
+            _flush()
+            buf.append(line)
+            in_fence = True
+        elif in_fence and is_fence:
+            # Closing fence
+            buf.append(line)
+            _flush()
+            in_fence = False
+        else:
+            buf.append(line)
+
+    _flush()
+    return [s for s in out if s != ""]
diff --git a/lark_channel/channel/outbound/media/__init__.py b/lark_channel/channel/outbound/media/__init__.py
new file mode 100644
index 0000000..0119e91
--- /dev/null
+++ b/lark_channel/channel/outbound/media/__init__.py
@@ -0,0 +1,11 @@
+"""Media subsystem: SSRF guard + zero-dep duration parsers."""
+
+from .duration_mp4 import parse_mp4_duration
+from .duration_ogg import parse_opus_duration
+from .ssrf_guard import assert_public_url
+
+__all__ = [
+    "assert_public_url",
+    "parse_mp4_duration",
+    "parse_opus_duration",
+]
diff --git a/lark_channel/channel/outbound/media/duration_mp4.py b/lark_channel/channel/outbound/media/duration_mp4.py
new file mode 100644
index 0000000..d54ae34
--- /dev/null
+++ b/lark_channel/channel/outbound/media/duration_mp4.py
@@ -0,0 +1,76 @@
+"""MP4 / ISO BMFF duration parser — zero dependencies.
+
+Walks the box tree looking for `moov/mvhd`, then reads `timescale` + `duration`
+from the mvhd payload. Handles:
+
+- Box size encoded as the first 4 bytes (big-endian uint32)
+- Extended size (`size == 1`): reads a 64-bit BE size at offset +8, payload
+  begins at offset +16
+- End-of-file markers (`size == 0` means "extends to EOF")
+- Two `mvhd` layout versions:
+    - v0 (version byte 0): times are 32-bit, duration at +16
+    - v1 (version byte 1): times are 64-bit, duration at +20
+
+Returns `None` on any malformed input.
+"""
+
+import struct
+from typing import Optional, Tuple
+
+
+def parse_mp4_duration(buf: bytes) -> Optional[int]:
+    """Return duration in milliseconds, or None if unparseable."""
+    moov = _find_box(buf, 0, len(buf), b"moov")
+    if moov is None:
+        return None
+    moov_start, moov_end = moov
+    mvhd = _find_box(buf, moov_start, moov_end, b"mvhd")
+    if mvhd is None:
+        return None
+    mvhd_start, mvhd_end = mvhd
+    if mvhd_end - mvhd_start < 32:
+        return None
+    version = buf[mvhd_start]
+    try:
+        if version == 0:
+            # creation(4) + modification(4) + timescale(4) + duration(4)
+            timescale = struct.unpack_from(">I", buf, mvhd_start + 12)[0]
+            duration = struct.unpack_from(">I", buf, mvhd_start + 16)[0]
+        else:
+            # creation(8) + modification(8) + timescale(4) + duration(8)
+            timescale = struct.unpack_from(">I", buf, mvhd_start + 20)[0]
+            duration = struct.unpack_from(">Q", buf, mvhd_start + 24)[0]
+    except struct.error:
+        return None
+    if not timescale or duration <= 0:
+        return None
+    return int(round((duration / timescale) * 1000))
+
+
+def _find_box(buf: bytes, start: int, end: int, wanted: bytes) -> Optional[Tuple[int, int]]:
+    """Scan sibling boxes between [start, end); return (payload_start, payload_end)."""
+    i = start
+    while i + 8 <= end:
+        try:
+            size = struct.unpack_from(">I", buf, i)[0]
+            box_type = buf[i + 4 : i + 8]
+        except struct.error:
+            return None
+        header_len = 8
+        if size == 1:
+            # Extended size — 64-bit follows
+            if i + 16 > end:
+                return None
+            size = struct.unpack_from(">Q", buf, i + 8)[0]
+            header_len = 16
+        elif size == 0:
+            # Extends to EOF
+            size = end - i
+        if size < header_len or i + size > end:
+            return None
+        payload_start = i + header_len
+        payload_end = i + size
+        if box_type == wanted:
+            return payload_start, payload_end
+        i += size
+    return None
diff --git a/lark_channel/channel/outbound/media/duration_ogg.py b/lark_channel/channel/outbound/media/duration_ogg.py
new file mode 100644
index 0000000..ec7b4e1
--- /dev/null
+++ b/lark_channel/channel/outbound/media/duration_ogg.py
@@ -0,0 +1,35 @@
+"""Opus-in-OGG duration parser — zero dependencies.
+
+Algorithm:
+
+1. Scan backward from end-of-buffer for the last `OggS` magic (4-byte `b"OggS"`)
+2. Read `granule_position` as little-endian int64 at offset +6
+3. Convert to milliseconds: Opus is always 48 kHz, so `ms = granule / 48`
+
+Returns `None` on any failure — malformed OGG, not-Opus, negative granule.
+"""
+
+import struct
+from typing import Optional
+
+OGG_MAGIC = b"OggS"
+OPUS_SAMPLES_PER_MS = 48  # Opus mandates a 48 kHz output rate
+
+
+def parse_opus_duration(buf: bytes) -> Optional[int]:
+    """Return duration in milliseconds, or None if unparseable."""
+    if not buf or len(buf) < 27:
+        return None
+    # Scan backward for the last OggS page
+    i = len(buf) - 27
+    while i >= 0:
+        if buf[i : i + 4] == OGG_MAGIC:
+            try:
+                granule = struct.unpack_from("<q", buf, i + 6)[0]
+            except struct.error:
+                return None
+            if granule < 0:
+                return None
+            return int(round(granule / OPUS_SAMPLES_PER_MS))
+        i -= 1
+    return None
diff --git a/lark_channel/channel/outbound/media/ssrf_guard.py b/lark_channel/channel/outbound/media/ssrf_guard.py
new file mode 100644
index 0000000..a8de669
--- /dev/null
+++ b/lark_channel/channel/outbound/media/ssrf_guard.py
@@ -0,0 +1,174 @@
+"""SSRF guard for outbound media URL fetches.
+
+We block DNS-resolved IPs that fall into well-known private / link-local /
+loopback / multicast / reserved CIDR blocks, including IPv6 equivalents and
+IPv4-embedding IPv6 forms (``::ffff:``, ``2002::``, ``64:ff9b::``, Teredo).
+
+**Important caveat — TOCTOU / DNS-rebinding.** This guard resolves the
+hostname once to validate the IPs, but :mod:`httpx` then performs its own
+DNS resolution when it actually connects. An attacker who controls DNS for
+the hostname (short TTL) can return a public IP to the guard and a private
+IP (e.g. ``169.254.169.254``) to httpx. Fully closing that window requires
+pinning the resolved IP into the transport, which is not implemented here.
+
+For that reason, the :mod:`..uploader` caller **requires an explicit
+hostname allowlist** when downloading from URLs — this guard is defense in
+depth, not a full boundary. If you need URL downloads in a hostile-input
+environment, provide an allowlist of trusted content hosts. Otherwise use
+``kind='buffer'`` or ``kind='file'`` media sources.
+"""
+
+import asyncio
+import ipaddress
+import socket
+from typing import List, Optional
+from urllib.parse import urlparse
+
+from ...errors import FeishuChannelErrorCode, FeishuChannelError
+
+# IPv4 CIDR blocklist: private / loopback / link-local / multicast / reserved.
+_BLOCKED_V4 = [
+    ("0.0.0.0", 8),        # this-network
+    ("10.0.0.0", 8),       # private
+    ("127.0.0.0", 8),      # loopback
+    ("169.254.0.0", 16),   # link-local
+    ("172.16.0.0", 12),    # private
+    ("192.168.0.0", 16),   # private
+    ("100.64.0.0", 10),    # CGNAT
+    ("192.0.0.0", 24),     # protocol assignments
+    ("192.0.2.0", 24),     # TEST-NET-1
+    ("198.18.0.0", 15),    # benchmarking
+    ("198.51.100.0", 24),  # TEST-NET-2
+    ("203.0.113.0", 24),   # TEST-NET-3
+    ("224.0.0.0", 4),      # multicast
+    ("240.0.0.0", 4),      # reserved
+]
+
+
+def _ipv4_blocked(ip: str) -> bool:
+    try:
+        addr = ipaddress.IPv4Address(ip)
+    except ValueError:
+        return False
+    for network, prefix in _BLOCKED_V4:
+        try:
+            if addr in ipaddress.IPv4Network(f"{network}/{prefix}", strict=False):
+                return True
+        except ValueError:
+            continue
+    return False
+
+
+def _ipv6_blocked(ip: str) -> bool:
+    try:
+        addr = ipaddress.IPv6Address(ip)
+    except ValueError:
+        return False
+    if addr.is_loopback or addr.is_link_local or addr.is_multicast or addr.is_unspecified:
+        return True
+    # Unique local addresses (fc00::/7)
+    if addr.packed[0] in (0xfc, 0xfd):
+        return True
+    # IPv4-mapped (::ffff:a.b.c.d) delegates to IPv4 policy.
+    if addr.ipv4_mapped is not None:
+        return _ipv4_blocked(str(addr.ipv4_mapped))
+    # 6to4 (2002::/16) embeds an IPv4 in bits 16-47 — delegate to IPv4 policy
+    # so 2002:a9fe:a9fe:: (encoding 169.254.169.254) is blocked.
+    if addr.sixtofour is not None:
+        return _ipv4_blocked(str(addr.sixtofour))
+    # NAT64 well-known prefix 64:ff9b::/96 embeds an IPv4 in the low 32 bits.
+    # ipaddress has no property for this; check prefix manually.
+    if addr.packed[:12] == b"\x00\x64\xff\x9b\x00\x00\x00\x00\x00\x00\x00\x00":
+        embedded_v4 = ".".join(str(b) for b in addr.packed[12:])
+        return _ipv4_blocked(embedded_v4)
+    # Teredo (2001::/32) embeds an IPv4 client address in bits 96-127 (inverted).
+    if addr.teredo is not None:
+        # teredo returns (server_v4, client_v4); the client is the one actually
+        # reachable by the packet's destination, so check both.
+        server_v4, client_v4 = addr.teredo
+        if _ipv4_blocked(str(server_v4)) or _ipv4_blocked(str(client_v4)):
+            return True
+    return False
+
+
+async def assert_public_url(
+    url: str,
+    *,
+    allowlist: Optional[List[str]] = None,
+) -> None:
+    """Raise FeishuChannelError(ssrf_blocked) if `url` resolves to a private IP.
+
+    - Protocol must be http/https.
+    - If `hostname` is in `allowlist`, we skip DNS + IP checks.
+    - Otherwise we `getaddrinfo` the hostname and verify every resolved
+      address is public.
+    """
+    try:
+        u = urlparse(url)
+    except ValueError as e:
+        raise FeishuChannelError(
+            FeishuChannelErrorCode.SSRF_BLOCKED,
+            f"invalid url: {e}",
+            context={"url": redact_url_for_log(url)},
+        ) from e
+    safe_url = redact_url_for_log(url)
+    if u.scheme not in ("http", "https"):
+        raise FeishuChannelError(
+            FeishuChannelErrorCode.SSRF_BLOCKED,
+            f"protocol {u.scheme!r} not allowed",
+            context={"url": safe_url},
+        )
+    hostname = u.hostname or ""
+    if not hostname:
+        raise FeishuChannelError(
+            FeishuChannelErrorCode.SSRF_BLOCKED,
+            "url has no hostname",
+            context={"url": safe_url},
+        )
+    if allowlist and hostname in allowlist:
+        return
+
+    # Resolve hostname via getaddrinfo; offload to thread so we don't block.
+    loop = asyncio.get_running_loop()
+    try:
+        infos = await loop.run_in_executor(
+            None, lambda: socket.getaddrinfo(hostname, None)
+        )
+    except socket.gaierror as e:
+        raise FeishuChannelError(
+            FeishuChannelErrorCode.SSRF_BLOCKED,
+            f"dns resolve failed: {e}",
+            context={"url": safe_url, "hostname": hostname},
+        ) from e
+
+    for family, _type, _proto, _canon, sockaddr in infos:
+        ip = sockaddr[0] if isinstance(sockaddr, tuple) else None
+        if not ip:
+            continue
+        if family == socket.AF_INET and _ipv4_blocked(ip):
+            raise FeishuChannelError(
+                FeishuChannelErrorCode.SSRF_BLOCKED,
+                f"blocked ipv4 {ip}",
+                context={"url": safe_url, "ip": ip},
+            )
+        if family == socket.AF_INET6 and _ipv6_blocked(ip):
+            raise FeishuChannelError(
+                FeishuChannelErrorCode.SSRF_BLOCKED,
+                f"blocked ipv6 {ip}",
+                context={"url": safe_url, "ip": ip},
+            )
+
+
+def redact_url_for_log(url: str) -> str:
+    """Return a URL safe for logs/errors: no credentials, query, or fragment."""
+    try:
+        u = urlparse(url)
+        hostname = u.hostname or ""
+        if not hostname:
+            return "<invalid-url>"
+        netloc = hostname
+        if u.port is not None:
+            netloc = f"{netloc}:{u.port}"
+        return u._replace(netloc=netloc, query="", fragment="").geturl()
+    except Exception:
+        return "<redacted-url>"
diff --git a/lark_channel/channel/outbound/media/uploader.py b/lark_channel/channel/outbound/media/uploader.py
new file mode 100644
index 0000000..a36c9bd
--- /dev/null
+++ b/lark_channel/channel/outbound/media/uploader.py
@@ -0,0 +1,316 @@
+"""Media upload helpers — resolve a :class:`MediaSource` to a Lark ``file_key``.
+
+Extracted from :mod:`..sender` so the sender can stay focused on message
+composition. Aligned with node-sdk's ``channel/outbound/media/uploader.ts``.
+
+The uploader:
+    1. Passes through pre-resolved ``key`` sources unchanged.
+    2. Gathers bytes for ``buffer``, ``file``, and ``url`` sources (SSRF-
+       guarding URLs by default).
+    3. Delegates the actual upload to the :class:`SendDriver`'s
+       ``upload_image`` / ``upload_file`` callback.
+
+Runtime failures are surfaced as :class:`FeishuChannelError`; ``None`` is
+reserved for caller-constructed "nothing to upload" inputs.
+"""
+
+import asyncio
+import inspect
+import os
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+from lark_channel.core.log import logger
+
+from ...errors import FeishuChannelError, FeishuChannelErrorCode
+from ...types import MediaSource
+from .ssrf_guard import assert_public_url, redact_url_for_log
+
+# 50 MiB default cap on URL-sourced downloads. Prevents an attacker URL that
+# returns an unbounded body from exhausting worker RAM. Tune via
+# ``_url_download_cap`` on the ``MediaSource`` if callers need a larger cap.
+_URL_DOWNLOAD_DEFAULT_CAP = 50 * 1024 * 1024
+
+
+async def resolve_media_key(
+    driver,
+    source: Optional[MediaSource],
+    kind: str,
+    *,
+    file_name: Optional[str] = None,
+    file_type: Optional[str] = None,
+    ssrf_allowlist: Optional[List[str]] = None,
+) -> Optional[str]:
+    """Return a Lark file_key for ``source``, uploading if needed.
+
+    ``kind`` selects the driver endpoint: ``"image"`` → ``upload_image``,
+    anything else → ``upload_file``. ``ssrf_allowlist`` (if given) supplies the
+    sender-level default from ``OutboundConfig.ssrf_allowlist``; an explicit
+    per-source allowlist still takes precedence.
+
+    **Error propagation.** Three failure modes, each surfaced to the caller
+    with a typed :class:`FeishuChannelError` code so the sender can map it
+    onto a ``SendResult.fail`` with the right taxonomy instead of the
+    previous "empty body" catch-all (which lost the real code / msg):
+
+    - ``UPLOAD_FAILED`` — the upload API returned a non-zero code or the
+      underlying transport raised (network / TLS / auth). ``context`` carries
+      ``raw_code`` and ``raw_msg`` pulled from the server response so the
+      caller can see exactly why it failed.
+    - ``SSRF_BLOCKED`` — ``gather_buffer`` raised (URL + no allowlist, or a
+      resolved IP in a blocked CIDR). Bubbled through unchanged.
+    - Returns ``None`` only for "nothing to upload" cases: ``source`` is
+      None, or ``source.kind == "key"`` with an empty ``key``. These are
+      caller-constructed inputs, not runtime failures.
+    """
+    if source is None:
+        return None
+    if source.kind == "key" and source.key:
+        return source.key
+
+    uploader = driver.upload_image if kind == "image" else driver.upload_file
+    if uploader is None:
+        raise FeishuChannelError(
+            FeishuChannelErrorCode.UPLOAD_FAILED,
+            f"media uploader missing on driver; cannot send {kind}",
+            context={"kind": kind},
+        )
+
+    # Propagate an explicit allowlist onto the source, if the caller supplied
+    # one AND the source itself does not already set one. This lets the
+    # outbound config's default allowlist apply to every URL download.
+    if ssrf_allowlist and getattr(source, "_ssrf_allowlist", None) is None:
+        try:
+            source._ssrf_allowlist = list(ssrf_allowlist)  # type: ignore[attr-defined]
+        except Exception:  # pragma: no cover - frozen dataclass
+            pass
+
+    # ``gather_buffer`` raises FeishuChannelError(SSRF_BLOCKED) for URL
+    # sources without an allowlist; let that propagate. For buffer / file
+    # sources that just fail to read, it still returns (None, default) —
+    # we map that to UPLOAD_FAILED so the caller doesn't get "empty body".
+    buffer, fname = await gather_buffer(source, default_name=file_name or "upload")
+    if buffer is None:
+        raise FeishuChannelError(
+            FeishuChannelErrorCode.UPLOAD_FAILED,
+            f"could not gather bytes for {kind} (source kind={source.kind!r})",
+            context={"kind": kind, "source_kind": source.kind},
+        )
+
+    kwargs: Dict[str, Any] = {"data": buffer, "file_name": fname}
+    if file_type:
+        kwargs["file_type"] = file_type
+    try:
+        raw = await _maybe_await(uploader(**kwargs))
+    except FeishuChannelError:
+        # Already typed — don't double-wrap.
+        raise
+    except Exception as e:
+        raise FeishuChannelError(
+            FeishuChannelErrorCode.UPLOAD_FAILED,
+            f"{kind} upload transport error: {e}",
+            context={"kind": kind},
+        ) from e
+    resp = _unwrap(raw)
+    if resp.get("code") != 0:
+        raw_code = resp.get("code")
+        raw_msg = resp.get("msg") or ""
+        raise FeishuChannelError(
+            FeishuChannelErrorCode.UPLOAD_FAILED,
+            f"{kind} upload rejected by server: code={raw_code} msg={raw_msg}",
+            context={"kind": kind, "raw_code": raw_code, "raw_msg": raw_msg},
+        )
+    data = resp.get("data") or {}
+    key = data.get("image_key") or data.get("file_key")
+    if not key:
+        # Response came back with code=0 but no key — malformed server
+        # response or mismatched endpoint. Surface instead of swallowing.
+        raise FeishuChannelError(
+            FeishuChannelErrorCode.UPLOAD_FAILED,
+            f"{kind} upload succeeded (code=0) but response missing image_key / file_key",
+            context={"kind": kind, "data_keys": list(data.keys())},
+        )
+    return key
+
+
+async def gather_buffer(
+    source: MediaSource, default_name: str
+) -> Tuple[Optional[bytes], str]:
+    """Collect a :class:`MediaSource`'s bytes + filename.
+
+    File reads are off-loaded to a worker thread so a large attachment does
+    not block the event loop. URL downloads stream with a byte cap to bound
+    memory use and hard-require an allowlist to contain SSRF blast radius —
+    see the module-level policy note and :func:`.ssrf_guard.assert_public_url`.
+    """
+    if source.kind == "buffer" and source.buffer is not None:
+        return source.buffer, default_name
+    if source.kind == "file" and source.path:
+        try:
+            path_str = source.path
+            loop = asyncio.get_running_loop()
+            data = await loop.run_in_executor(
+                None, lambda: Path(path_str).read_bytes()
+            )
+            return data, os.path.basename(path_str) or default_name
+        except OSError as e:
+            # Preserve the concrete OSError reason (FileNotFoundError,
+            # PermissionError, IsADirectoryError, ...) via ``from e`` and
+            # surface it as a typed ``UPLOAD_FAILED`` so callers keep the
+            # concrete diagnostic instead of seeing a generic send failure.
+            raise FeishuChannelError(
+                FeishuChannelErrorCode.UPLOAD_FAILED,
+                f"could not read local file {source.path!r}: {e}",
+                context={"path": source.path, "source_kind": "file"},
+            ) from e
+    if source.kind == "url" and source.url:
+        safe_url = redact_url_for_log(source.url)
+        # SSRF guard is mandatory for URL downloads unless an explicit
+        # hostname allowlist is provided by the caller. The guard protects
+        # against DNS-resolved private / loopback / metadata IPs, but it
+        # *cannot* close the TOCTOU window between DNS check and HTTP connect
+        # when hostname DNS is attacker-controlled (see ssrf_guard module
+        # docstring). An allowlist of trusted hostnames is the only way to
+        # make URL uploads safe in hostile-input environments.
+        allowlist = getattr(source, "_ssrf_allowlist", None)
+        ssrf = getattr(source, "_ssrf_guard", True)
+        if not ssrf:
+            logger.warning(
+                "outbound: SSRF guard explicitly disabled for %s — this is "
+                "only safe when the URL is fully trusted",
+                safe_url,
+            )
+        elif not allowlist:
+            # No allowlist configured → hard stop. Raise a typed error so
+            # the caller sees ``code=SSRF_BLOCKED`` and can surface that to
+            # the user; silently returning ``(None, name)`` would be
+            # ambiguous with a transient network failure.
+            raise FeishuChannelError(
+                FeishuChannelErrorCode.SSRF_BLOCKED,
+                (
+                    f"refusing URL download for {safe_url} — no SSRF "
+                    "allowlist configured; set "
+                    "OutboundConfig.ssrf_allowlist to trusted hostnames or "
+                    "use kind='buffer'/'file' instead"
+                ),
+                context={"url": safe_url},
+            )
+        else:
+            # Let assert_public_url's FeishuChannelError propagate up as
+            # the typed SSRF_BLOCKED error. The earlier swallow-to-None
+            # made the block indistinguishable from a download failure.
+            await assert_public_url(source.url, allowlist=allowlist)
+
+        cap = int(getattr(source, "_url_download_cap", _URL_DOWNLOAD_DEFAULT_CAP))
+        try:
+            import httpx  # type: ignore
+
+            async with httpx.AsyncClient(
+                timeout=30, follow_redirects=False
+            ) as client:
+                async with client.stream("GET", source.url) as r:
+                    r.raise_for_status()
+                    # Short-circuit when Content-Length already exceeds cap.
+                    cl = r.headers.get("content-length")
+                    if cl is not None:
+                        try:
+                            if int(cl) > cap:
+                                raise FeishuChannelError(
+                                    FeishuChannelErrorCode.UPLOAD_FAILED,
+                                    (
+                                        f"URL download refused — response "
+                                        f"content-length={cl} exceeds cap "
+                                        f"({cap} bytes)"
+                                    ),
+                                    context={
+                                        "url": safe_url,
+                                        "content_length": cl,
+                                        "cap": cap,
+                                    },
+                                )
+                        except ValueError:
+                            pass
+                    chunks: List[bytes] = []
+                    total = 0
+                    async for chunk in r.aiter_bytes():
+                        total += len(chunk)
+                        if total > cap:
+                            raise FeishuChannelError(
+                                FeishuChannelErrorCode.UPLOAD_FAILED,
+                                (
+                                    f"URL download exceeded cap mid-stream "
+                                    f"({total} > {cap} bytes)"
+                                ),
+                                context={
+                                    "url": safe_url,
+                                    "bytes_read": total,
+                                    "cap": cap,
+                                },
+                            )
+                        chunks.append(chunk)
+                    name = filename_from_url(source.url, default_name)
+                    return b"".join(chunks), name
+        except FeishuChannelError:
+            # Already typed (either our own UPLOAD_FAILED cap violation or a
+            # SSRF_BLOCKED from assert_public_url running inside httpx).
+            raise
+        except Exception as e:
+            # Network / TLS / DNS / HTTP-status failures — preserve the
+            # concrete exception via ``from e`` instead of losing it.
+            raise FeishuChannelError(
+                FeishuChannelErrorCode.UPLOAD_FAILED,
+                f"URL download of {safe_url} failed: {e}",
+                context={"url": safe_url, "source_kind": "url"},
+            ) from e
+    # Fallthrough: source.kind wasn't one of buffer/file/url, or required
+    # attribute missing (e.g. kind="file" with path=None). Caller-constructed
+    # input, not a runtime failure — keep the None-None return contract.
+    return None, default_name
+
+
+def filename_from_url(url: str, default: str) -> str:
+    try:
+        from urllib.parse import urlparse
+
+        p = urlparse(url).path or ""
+        base = os.path.basename(p)
+        # Defense in depth: strip NUL and any path-traversal artefacts from the
+        # attacker-controlled URL path before the name flows into the uploader.
+        base = base.replace("\x00", "").replace("/", "").replace("\\", "")
+        if len(base) > 255:
+            base = base[-255:]
+        return base or default
+    except Exception:  # pragma: no cover - defensive
+        return default
+
+
+async def _maybe_await(v: Any) -> Any:
+    if inspect.isawaitable(v):
+        return await v
+    return v
+
+
+def _unwrap(result: Any) -> Dict[str, Any]:
+    """Normalize a driver upload response to a plain dict shape."""
+    if result is None:
+        return {"code": -1, "msg": "empty response"}
+    if isinstance(result, dict):
+        return result
+    code = getattr(result, "code", None)
+    if code is None:
+        return {"code": -1, "msg": "unknown response"}
+    data = getattr(result, "data", None)
+    out: Dict[str, Any] = {"code": code, "msg": getattr(result, "msg", "") or ""}
+    if data is not None:
+        if isinstance(data, dict):
+            out["data"] = data
+        else:
+            try:
+                out["data"] = {
+                    k: getattr(data, k)
+                    for k in dir(data)
+                    if not k.startswith("_") and not callable(getattr(data, k))
+                }
+            except Exception:  # pragma: no cover - defensive
+                out["data"] = {}
+    return out
diff --git a/lark_channel/channel/outbound/retry.py b/lark_channel/channel/outbound/retry.py
new file mode 100644
index 0000000..c341517
--- /dev/null
+++ b/lark_channel/channel/outbound/retry.py
@@ -0,0 +1,94 @@
+"""Exponential-backoff retry for transient outbound failures.
+
+Defaults:
+    - 3 attempts total (1 initial + 2 retries)
+    - ``500ms * 3 ** attempt`` backoff (500ms, 1.5s, 4.5s ...), capped at
+      ``DEFAULT_MAX_DELAY_MS`` to avoid multi-minute waits under repeated
+      failure.
+
+If the ``SendError`` carries a ``retry_after_seconds`` value (populated from
+an upstream ``Retry-After`` header on 429s), that value overrides the
+computed backoff — honouring server-signalled rate limits rather than
+hammering with a smaller client-side delay. We still cap the absolute wait
+to ``DEFAULT_MAX_RETRY_AFTER_S`` so a misbehaving server can't stall a
+caller for minutes.
+
+Only retries when the caller flags the last result as retryable; other
+failures are returned immediately.
+"""
+
+import asyncio
+import random
+from typing import Awaitable, Callable, Optional
+
+from ..errors import SendError, is_retryable
+from ..types import SendResult
+
+DEFAULT_MAX_ATTEMPTS = 3
+DEFAULT_BASE_DELAY_MS = 500
+DEFAULT_MAX_DELAY_MS = 30_000
+DEFAULT_MAX_RETRY_AFTER_S = 60.0
+
+
+async def with_retry(
+    op: Callable[[int], Awaitable[SendResult]],
+    *,
+    max_attempts: int = DEFAULT_MAX_ATTEMPTS,
+    base_delay_ms: int = DEFAULT_BASE_DELAY_MS,
+    max_delay_ms: int = DEFAULT_MAX_DELAY_MS,
+    jitter: bool = True,
+) -> SendResult:
+    """Call `op(attempt)` up to `max_attempts` times with backoff.
+
+    `op` is expected to return a `SendResult`. If `result.success` is False
+    and the error is retryable (see `errors.is_retryable`), we back off and
+    try again; otherwise we short-circuit.
+    """
+    last: Optional[SendResult] = None
+    for attempt in range(max_attempts):
+        result = await op(attempt)
+        if result.success:
+            return result
+        last = result
+        if result.error is None or not _should_retry(result.error):
+            return result
+        # Not the last attempt → sleep then retry
+        if attempt >= max_attempts - 1:
+            return result
+        delay = _compute_delay(
+            result.error, attempt,
+            base_delay_ms=base_delay_ms,
+            max_delay_ms=max_delay_ms,
+            jitter=jitter,
+        )
+        await asyncio.sleep(delay)
+    if last is None:
+        raise RuntimeError("with_retry: no attempt was made (max_attempts<=0?)")
+    return last
+
+
+def _compute_delay(
+    err: SendError, attempt: int, *,
+    base_delay_ms: int, max_delay_ms: int, jitter: bool,
+) -> float:
+    """Compute seconds to sleep before the next retry.
+
+    Server-signalled ``retry_after_seconds`` wins when present; otherwise
+    fall back to exponential backoff with optional jitter, capped at
+    ``max_delay_ms``.
+    """
+    if err.retry_after_seconds is not None and err.retry_after_seconds > 0:
+        # Bound to a sane ceiling so a broken upstream can't stall the
+        # caller for multi-minute waits.
+        return min(float(err.retry_after_seconds), DEFAULT_MAX_RETRY_AFTER_S)
+    delay_ms = min(base_delay_ms * (3 ** attempt), max_delay_ms)
+    delay = delay_ms / 1000.0
+    if jitter:
+        delay *= 0.7 + 0.6 * random.random()
+    return delay
+
+
+def _should_retry(err: SendError) -> bool:
+    # Honor both the `retryable` flag set by `classify_error` (legacy) and
+    # the aligned error-code predicate.
+    return bool(err.retryable or is_retryable(err.code))
diff --git a/lark_channel/channel/outbound/routing.py b/lark_channel/channel/outbound/routing.py
new file mode 100644
index 0000000..7dfdef4
--- /dev/null
+++ b/lark_channel/channel/outbound/routing.py
@@ -0,0 +1,25 @@
+"""Infer `receive_id_type` for Lark's `POST /im/v1/messages` endpoint.
+
+Lark requires you to say whether `receive_id` is an open_id, chat_id, user_id,
+union_id, or email. In channel use cases the id format is usually obvious from
+the prefix, so we auto-detect.
+"""
+
+from typing import Literal
+
+ReceiveIdType = Literal["open_id", "chat_id", "user_id", "union_id", "email"]
+
+
+def infer_receive_id_type(receive_id: str) -> ReceiveIdType:
+    if not receive_id:
+        return "chat_id"
+    if "@" in receive_id:
+        return "email"
+    if receive_id.startswith("ou_"):
+        return "open_id"
+    if receive_id.startswith("oc_"):
+        return "chat_id"
+    if receive_id.startswith("on_"):
+        return "union_id"
+    # Anything else is likely a user_id or custom identifier.
+    return "user_id"
diff --git a/lark_channel/channel/outbound/sender.py b/lark_channel/channel/outbound/sender.py
new file mode 100644
index 0000000..f4ef5ea
--- /dev/null
+++ b/lark_channel/channel/outbound/sender.py
@@ -0,0 +1,745 @@
+"""Outbound sender: translates OutboundMessage → Lark SDK calls.
+
+The sender is deliberately I/O-light: it composes the right request body and
+delegates to a caller-supplied :class:`SendDriver`. In production the driver
+is backed by ``lark_channel.Client``; tests inject fakes.
+
+Media-upload concerns (resolving a :class:`MediaSource` into a Lark
+``file_key``) live in :mod:`.media.uploader`.
+"""
+
+import inspect
+import json
+import uuid
+from dataclasses import dataclass
+from typing import Any, Awaitable, Callable, Dict, List, Optional, Tuple, Union
+
+from lark_channel.core.log import logger
+
+from ..config import OutboundConfig
+from ..errors import (
+    FeishuChannelError,
+    FeishuChannelErrorCode,
+    SendError,
+    classify_error,
+    is_format_error,
+    is_reply_target_gone,
+)
+from .retry import with_retry
+from .media.uploader import resolve_media_key
+from ..types import (
+    OutboundAudio,
+    OutboundCard,
+    OutboundFile,
+    OutboundImage,
+    OutboundMessage,
+    OutboundPost,
+    OutboundShareChat,
+    OutboundShareUser,
+    OutboundSticker,
+    OutboundText,
+    OutboundVideo,
+    SendResult,
+)
+from .markdown import markdown_to_post_ast, split_with_code_fences
+from .routing import infer_receive_id_type
+
+# ----------------------------------------------------------------------------
+# Plain-text chunking — kept local to the sender (node-aligned). Only the
+# markdown-aware `split_with_code_fences` lives in :mod:`.markdown.splitter`.
+# ----------------------------------------------------------------------------
+
+_ChunkMode = str  # "newline" | "paragraph" | "none"
+
+
+def chunk_text(text: str, limit: int = 3500, mode: _ChunkMode = "newline") -> list:
+    """Split ``text`` into ordered chunks of <= ``limit`` chars.
+
+    - ``newline``: prefers breaking at the last ``\\n`` within the window.
+    - ``paragraph``: prefers breaking at blank-line boundaries.
+    - ``none``: hard slice at ``limit`` chars.
+    """
+    if not text:
+        return []
+    if limit <= 0:
+        return [text]
+    if len(text) <= limit:
+        return [text]
+    if mode == "none":
+        return [text[i : i + limit] for i in range(0, len(text), limit)]
+    if mode == "paragraph":
+        return _chunk_by_delim(text, limit, delim="\n\n")
+    return _chunk_by_delim(text, limit, delim="\n")
+
+
+def _chunk_by_delim(text: str, limit: int, delim: str) -> list:
+    chunks = []
+    i = 0
+    n = len(text)
+    delim_len = len(delim)
+    while i < n:
+        if n - i <= limit:
+            chunks.append(text[i:])
+            break
+        window = text[i : i + limit]
+        idx = window.rfind(delim)
+        if idx <= 0:
+            chunks.append(window)
+            i += limit
+        else:
+            chunks.append(window[:idx])
+            i += idx + delim_len
+    return [c for c in chunks if c]
+
+
+# ----------------------------------------------------------------------------
+# Driver protocol — the thin seam between the sender and the Lark HTTP client.
+# Each method takes a dict "body" payload + keyword args and returns a dict
+# with at least {code, msg, data?}. Async or sync callables are both allowed.
+# ----------------------------------------------------------------------------
+
+SendFn = Callable[..., Union[Dict[str, Any], Awaitable[Dict[str, Any]]]]
+
+
+@dataclass
+class SendDriver:
+    create_message: SendFn
+    reply_message: SendFn
+    patch_message: Optional[SendFn] = None
+    delete_message: Optional[SendFn] = None
+    forward_message: Optional[SendFn] = None
+    upload_image: Optional[SendFn] = None
+    upload_file: Optional[SendFn] = None
+
+
+class _OversizeHookFailure(Exception):
+    """Internal: marker for an OutboundConfig.on_oversize hook exception so
+    the broad ``except Exception`` in send() can re-raise the original
+    instead of swallowing into SendResult.fail(UNKNOWN). Hook exceptions
+    propagate to the caller without silent fallback.
+    """
+
+    def __init__(self, original: BaseException):
+        self.original = original
+        super().__init__(str(original))
+
+
+class _UnsupportedMediaCaption(Exception):
+    """Internal: media caption shape is not supported by Lark post messages."""
+
+    def __init__(self, media_kind: str):
+        self.media_kind = media_kind
+        super().__init__(
+            f"{media_kind} caption is not supported by Lark post messages; "
+            "send the caption as a separate message if two-message semantics are acceptable"
+        )
+
+
+async def _maybe_await(v: Any) -> Any:
+    if inspect.isawaitable(v):
+        return await v
+    return v
+
+
+def _unwrap(result: Any) -> Dict[str, Any]:
+    """Normalize driver output to a plain dict shape."""
+    if result is None:
+        return {"code": -1, "msg": "empty response"}
+    if isinstance(result, dict):
+        return result
+    # If it's an object from the SDK with .code / .msg / .data, fall back.
+    code = getattr(result, "code", None)
+    if code is None:
+        return {"code": -1, "msg": "unknown response"}
+    data = getattr(result, "data", None)
+    out = {"code": code, "msg": getattr(result, "msg", "") or ""}
+    if data is not None:
+        # data may be a model object; try to coerce to dict.
+        if isinstance(data, dict):
+            out["data"] = data
+        else:
+            try:
+                out["data"] = {
+                    k: getattr(data, k)
+                    for k in dir(data)
+                    if not k.startswith("_") and not callable(getattr(data, k))
+                }
+            except Exception:  # pragma: no cover - defensive
+                out["data"] = {}
+    return out
+
+
+def _extract_message_id(resp: Dict[str, Any]) -> Optional[str]:
+    data = resp.get("data") or {}
+    if not isinstance(data, dict):
+        return None
+    return data.get("message_id") or data.get("id")
+
+
+# ----------------------------------------------------------------------------
+# Content builders — turn an OutboundMessage into a `msg_type` + content JSON.
+# ----------------------------------------------------------------------------
+
+
+def _build_text(msg: OutboundText) -> Dict[str, str]:
+    # Inject <at> tags for mentioned identities so they get notified.
+    at_prefix = ""
+    for ident in msg.mentions or []:
+        if ident and ident.open_id:
+            name = ident.display_name or ""
+            at_prefix += f'<at user_id="{ident.open_id}">{name}</at> '
+    content = at_prefix + (msg.text or "")
+    return {"msg_type": "text", "content": json.dumps({"text": content}, ensure_ascii=False)}
+
+
+def _build_post(
+    msg: OutboundPost,
+    table_mode: str = "off",
+    tag_md_mode: str = "structured",
+) -> Dict[str, str]:
+    """Build a Feishu post-message body.
+
+    Feishu's ``im.v1.message.create`` expects ``content`` for ``msg_type=post``
+    to be the JSON-serialised locale map directly (``{zh_cn: {title, content}}``)
+    — NO outer ``{"post": ...}`` wrapper. Wrapping it yields server error
+    ``230001 invalid message content``. Node SDK verified at sender.ts uses
+    the same unwrapped shape.
+    """
+    if msg.post is not None:
+        post = msg.post
+    elif msg.markdown is not None:
+        post = markdown_to_post_ast(
+            msg.markdown,
+            title=msg.title or "",
+            mentions=list(msg.mentions or []),
+            table_mode=table_mode,
+            tag_md_mode=tag_md_mode,
+        )
+    else:
+        post = {"zh_cn": {"title": msg.title or "", "content": [[{"tag": "text", "text": ""}]]}}
+    return {"msg_type": "post", "content": json.dumps(post, ensure_ascii=False)}
+
+
+def _build_media_caption_post(
+    *,
+    caption: str,
+    media_node: Dict[str, Any],
+    table_mode: str = "off",
+    tag_md_mode: str = "structured",
+) -> Dict[str, str]:
+    post = markdown_to_post_ast(
+        caption,
+        title="",
+        table_mode=table_mode,
+        tag_md_mode=tag_md_mode,
+    )
+    zh = post.setdefault("zh_cn", {"title": "", "content": []})
+    rows = zh.setdefault("content", [])
+    rows.append([media_node])
+    return {"msg_type": "post", "content": json.dumps(post, ensure_ascii=False)}
+
+
+def _build_card(msg: OutboundCard) -> Dict[str, str]:
+    if msg.card_id:
+        content = {"type": "card", "data": {"card_id": msg.card_id}}
+    else:
+        content = msg.card
+    return {"msg_type": "interactive", "content": json.dumps(content, ensure_ascii=False)}
+
+
+def _build_image(image_key: str) -> Dict[str, str]:
+    return {"msg_type": "image", "content": json.dumps({"image_key": image_key}, ensure_ascii=False)}
+
+
+def _build_file(file_key: str) -> Dict[str, str]:
+    return {"msg_type": "file", "content": json.dumps({"file_key": file_key}, ensure_ascii=False)}
+
+
+def _build_audio(file_key: str) -> Dict[str, str]:
+    return {"msg_type": "audio", "content": json.dumps({"file_key": file_key}, ensure_ascii=False)}
+
+
+def _build_video(file_key: str) -> Dict[str, str]:
+    return {"msg_type": "media", "content": json.dumps({"file_key": file_key}, ensure_ascii=False)}
+
+
+def _build_share_chat(chat_id: str) -> Dict[str, str]:
+    return {
+        "msg_type": "share_chat",
+        "content": json.dumps({"chat_id": chat_id}, ensure_ascii=False),
+    }
+
+
+def _build_share_user(user_id: str) -> Dict[str, str]:
+    return {
+        "msg_type": "share_user",
+        "content": json.dumps({"user_id": user_id}, ensure_ascii=False),
+    }
+
+
+def _build_sticker(file_key: str) -> Dict[str, str]:
+    return {
+        "msg_type": "sticker",
+        "content": json.dumps({"file_key": file_key}, ensure_ascii=False),
+    }
+
+
+# ----------------------------------------------------------------------------
+# Sender
+# ----------------------------------------------------------------------------
+
+
+class OutboundSender:
+    def __init__(
+        self,
+        driver: SendDriver,
+        config: Optional[OutboundConfig] = None,
+        *,
+        on_success: Optional[Callable[[str], None]] = None,
+    ) -> None:
+        self._driver = driver
+        self._config = config or OutboundConfig()
+        # Optional callback invoked with the fresh message_id after each
+        # successful send — used by the channel to track own messages for the
+        # reaction 'own' filter.
+        self._on_success: Optional[Callable[[str], None]] = on_success
+        # Retry / SSRF knobs are read from ``self._config.retry`` and
+        # ``self._config.ssrf_allowlist`` at call time (see ``with_retry``
+        # invocations below and ``resolve_media_key`` call sites).
+
+    def _markdown_modes(self) -> Tuple[str, str]:
+        conv = self._config.markdown_converter
+        if getattr(conv, "enabled", True):
+            return conv.table_mode, getattr(conv, "tag_md_mode", "structured")
+        return "off", "structured"
+
+    async def materialize_for_edit(self, msg: OutboundMessage) -> Dict[str, str]:
+        """Materialize exactly one text/post body for message editing.
+
+        Unlike send materialization, this method does not chunk, does not call
+        the oversize hook, and does not apply reply or receive-id semantics.
+        """
+        if isinstance(msg, OutboundText):
+            return _build_text(msg)
+        if isinstance(msg, OutboundPost):
+            table_mode, tag_md_mode = self._markdown_modes()
+            return _build_post(msg, table_mode=table_mode, tag_md_mode=tag_md_mode)
+        raise TypeError(
+            f"materialize_for_edit: unsupported message type {type(msg).__name__}; "
+            "only OutboundText and OutboundPost are editable"
+        )
+
+    async def send(
+        self,
+        message: OutboundMessage,
+        *,
+        receive_id: Optional[str] = None,
+        receive_id_type: Optional[str] = None,
+        reply_to: Optional[str] = None,
+        reply_in_thread: Optional[bool] = None,
+        reply_target_gone: str = "fresh",
+        uuid_: Optional[str] = None,
+    ) -> SendResult:
+        """Route a single OutboundMessage through the driver.
+
+        Caller supplies either `receive_id` or `reply_to`. If both are given,
+        reply wins — we use `/im/v1/messages/:id/reply`.
+        """
+        try:
+            body_list = await self._materialize(
+                message,
+                chat_id=receive_id or "",
+                receive_id_type=receive_id_type or "",
+            )
+        except _OversizeHookFailure as f:
+            # Hook exceptions propagate to the caller without fallback.
+            raise f.original from f.original
+        except _UnsupportedMediaCaption as e:
+            logger.warning("outbound: unsupported media caption: %s", e)
+            return SendResult.fail(SendError(
+                code=FeishuChannelErrorCode.FORMAT_ERROR,
+                retryable=False,
+                hint=str(e),
+            ))
+        except FeishuChannelError as e:
+            # Preserve the typed error code (SSRF_BLOCKED, UPLOAD_FAILED, …)
+            # from the uploader / ssrf guard; wrapping into UNKNOWN loses
+            # the signal callers want to match on.
+            logger.warning("outbound: materialize blocked: %s", e)
+            return SendResult.fail(SendError(
+                code=e.code, retryable=False, hint=str(e),
+            ))
+        except Exception as e:
+            logger.exception("outbound: materialize failed: %s", e)
+            return SendResult.fail(SendError(code=FeishuChannelErrorCode.UNKNOWN, retryable=False, hint=str(e)))
+
+        if not body_list:
+            return SendResult.fail(SendError(code=FeishuChannelErrorCode.UNKNOWN, retryable=False, hint="empty body"))
+
+        # Collect every successful chunk's message_id. For single-chunk
+        # messages we return the familiar ``SendResult.ok(message_id=...)``.
+        # For multi-chunk (long markdown / post → multiple POST /messages
+        # requests), we also populate ``chunk_ids`` so callers can observe
+        # that the logical message was split. Node-sdk aligned.
+        chunk_message_ids: List[str] = []
+        last_result: SendResult = SendResult.fail(SendError(code=FeishuChannelErrorCode.UNKNOWN, retryable=False))
+        for idx, body in enumerate(body_list):
+            req_uuid = uuid_ if (idx == 0 and uuid_) else str(uuid.uuid4())
+            # Only apply `reply_to` to the first chunk; subsequent chunks are
+            # fresh messages so they all render in the original chat.
+            effective_reply_to = reply_to if idx == 0 else None
+            result = await self._send_one_with_fallback(
+                body=body,
+                receive_id=receive_id,
+                receive_id_type=receive_id_type,
+                reply_to=effective_reply_to,
+                reply_in_thread=reply_in_thread,
+                reply_target_gone=reply_target_gone,
+                uuid_=req_uuid,
+            )
+            last_result = result
+            if not result.success:
+                return result
+            if result.message_id:
+                chunk_message_ids.append(result.message_id)
+        # Augment the final success result with chunk_ids when >1 chunk.
+        if len(chunk_message_ids) > 1:
+            return SendResult.ok(
+                message_id=chunk_message_ids[0],
+                raw=last_result.raw,
+                chunk_ids=list(chunk_message_ids),
+            )
+        return last_result
+
+    async def _send_one_with_fallback(
+        self,
+        *,
+        body: Dict[str, str],
+        receive_id: Optional[str],
+        receive_id_type: Optional[str],
+        reply_to: Optional[str],
+        reply_in_thread: Optional[bool],
+        reply_target_gone: str,
+        uuid_: str,
+    ) -> SendResult:
+        """One send attempt with retry + two graceful downgrades.
+
+        - `target_revoked` when replying → retry as a fresh create.
+        - `format_error` on `post` → downgrade to plain text.
+        """
+        async def attempt(_: int) -> SendResult:
+            if reply_to:
+                return await self._reply(reply_to, body, reply_in_thread, uuid_)
+            rid = receive_id or ""
+            rit = receive_id_type or infer_receive_id_type(rid)
+            return await self._create(rid, rit, body, uuid_)
+
+        result = await with_retry(
+            attempt,
+            max_attempts=self._config.retry.max_attempts,
+            base_delay_ms=self._config.retry.base_delay_ms,
+        )
+        if result.success or result.error is None:
+            return result
+
+        err = result.error
+        # Downgrade 1: reply target gone → fresh send
+        if is_reply_target_gone(err.code) and reply_to:
+            if reply_target_gone == "fail":
+                return result
+            logger.info("outbound: reply target gone, retrying as fresh message")
+            async def fresh(_: int) -> SendResult:
+                rid = receive_id or ""
+                rit = receive_id_type or infer_receive_id_type(rid)
+                return await self._create(rid, rit, body, uuid_)
+            return await with_retry(fresh, max_attempts=self._config.retry.max_attempts,
+                                    base_delay_ms=self._config.retry.base_delay_ms)
+
+        # Downgrade 2: post rejected → fallback to plain text
+        if is_format_error(err.code) and body.get("msg_type") == "post":
+            logger.info("outbound: post format rejected, falling back to plain text")
+            plain = _post_to_plain_text_from_body(body.get("content", ""))
+            if plain:
+                text_body = {"msg_type": "text", "content": json.dumps({"text": plain}, ensure_ascii=False)}
+                async def fallback(_: int) -> SendResult:
+                    if reply_to:
+                        return await self._reply(reply_to, text_body, reply_in_thread, uuid_)
+                    rid = receive_id or ""
+                    rit = receive_id_type or infer_receive_id_type(rid)
+                    return await self._create(rid, rit, text_body, uuid_)
+                return await with_retry(fallback, max_attempts=self._config.retry.max_attempts,
+                                        base_delay_ms=self._config.retry.base_delay_ms)
+
+        return result
+
+    async def _materialize(
+        self,
+        msg: OutboundMessage,
+        *,
+        chat_id: str = "",
+        receive_id_type: str = "",
+    ) -> List[Dict[str, str]]:
+        if isinstance(msg, OutboundText):
+            text = msg.text or ""
+            replacement = await self._maybe_oversize_hook(
+                text, chat_id=chat_id, receive_id_type=receive_id_type,
+            )
+            if replacement:
+                replaced = OutboundText(text=replacement, mentions=msg.mentions)
+                return [_build_text(replaced)]
+
+            # Chunking for long text
+            chunks = chunk_text(
+                text,
+                limit=self._config.text_chunk_limit,
+                mode=self._config.chunk_mode,
+            ) or [""]
+            out: List[Dict[str, str]] = []
+            for i, chunk in enumerate(chunks):
+                part = OutboundText(
+                    text=chunk,
+                    mentions=msg.mentions if i == 0 else [],
+                )
+                out.append(_build_text(part))
+            return out
+        if isinstance(msg, OutboundPost):
+            table_mode, tag_md_mode = self._markdown_modes()
+            # Markdown-sourced posts get split (code-fence aware) when the raw
+            # markdown exceeds the configured chunk limit; each chunk becomes
+            # its own post body. Pre-built ``msg.post`` ASTs are sent as-is —
+            # they're opaque to us. Mentions go only on the first chunk so
+            # ``@user`` doesn't fire again on every fragment.
+            if msg.markdown is not None and len(msg.markdown) > self._config.text_chunk_limit:
+                replacement = await self._maybe_oversize_hook(
+                    msg.markdown, chat_id=chat_id, receive_id_type=receive_id_type,
+                )
+                if replacement:
+                    replaced = OutboundText(text=replacement, mentions=msg.mentions)
+                    return [_build_text(replaced)]
+                md_chunks = split_with_code_fences(
+                    msg.markdown, self._config.text_chunk_limit,
+                )
+                out: List[Dict[str, str]] = []
+                for i, chunk in enumerate(md_chunks):
+                    part = OutboundPost(
+                        markdown=chunk,
+                        title=msg.title if i == 0 else "",
+                        mentions=msg.mentions if i == 0 else [],
+                    )
+                    out.append(_build_post(part, table_mode=table_mode, tag_md_mode=tag_md_mode))
+                return out
+            return [_build_post(msg, table_mode=table_mode, tag_md_mode=tag_md_mode)]
+        if isinstance(msg, OutboundCard):
+            return [_build_card(msg)]
+        allowlist = self._config.ssrf_allowlist
+        if isinstance(msg, OutboundImage):
+            key = await resolve_media_key(
+                self._driver, msg.source, "image", ssrf_allowlist=allowlist
+            )
+            if not key:
+                return []
+            if msg.caption:
+                table_mode, tag_md_mode = self._markdown_modes()
+                return [_build_media_caption_post(
+                    caption=msg.caption,
+                    media_node={"tag": "img", "image_key": key},
+                    table_mode=table_mode,
+                    tag_md_mode=tag_md_mode,
+                )]
+            return [_build_image(key)]
+        if isinstance(msg, OutboundFile):
+            if msg.caption:
+                raise _UnsupportedMediaCaption("file")
+            key = await resolve_media_key(
+                self._driver, msg.source, "file",
+                file_name=msg.file_name, ssrf_allowlist=allowlist,
+            )
+            if not key:
+                return []
+            return [_build_file(key)]
+        if isinstance(msg, OutboundAudio):
+            if msg.caption:
+                raise _UnsupportedMediaCaption("audio")
+            key = await resolve_media_key(
+                self._driver, msg.source, "file",
+                file_type="opus", ssrf_allowlist=allowlist,
+            )
+            return [_build_audio(key)] if key else []
+        if isinstance(msg, OutboundVideo):
+            key = await resolve_media_key(
+                self._driver, msg.source, "file",
+                file_type="mp4", ssrf_allowlist=allowlist,
+            )
+            if msg.caption and key:
+                table_mode, tag_md_mode = self._markdown_modes()
+                return [_build_media_caption_post(
+                    caption=msg.caption,
+                    media_node={"tag": "media", "file_key": key},
+                    table_mode=table_mode,
+                    tag_md_mode=tag_md_mode,
+                )]
+            return [_build_video(key)] if key else []
+        if isinstance(msg, OutboundShareChat):
+            return [_build_share_chat(msg.chat_id)] if msg.chat_id else []
+        if isinstance(msg, OutboundShareUser):
+            return [_build_share_user(msg.user_id)] if msg.user_id else []
+        if isinstance(msg, OutboundSticker):
+            return [_build_sticker(msg.file_key)] if msg.file_key else []
+        return []
+
+    async def _maybe_oversize_hook(
+        self, text: str, *, chat_id: str, receive_id_type: str,
+    ) -> Optional[str]:
+        """Return non-empty replacement when the hook supplies one.
+
+        - No hook configured -> None (caller chunks normally).
+        - text within limit -> None (no oversize).
+        - hook returns None / empty -> None (fallback).
+        - hook returns non-empty str -> that string (single send).
+        - hook raises -> wrapped in _OversizeHookFailure so the caller's
+          broad `except Exception` doesn't accidentally swallow it; send()
+          unwraps and re-raises the original.
+        """
+        hook = self._config.on_oversize
+        if hook is None:
+            return None
+        if len(text) <= self._config.text_chunk_limit:
+            return None
+        from ..config import OversizeContext
+        estimated = max(
+            1,
+            (len(text) + self._config.text_chunk_limit - 1) // self._config.text_chunk_limit,
+        )
+        ctx = OversizeContext(
+            text=text,
+            chat_id=chat_id,
+            receive_id_type=receive_id_type,
+            estimated_chunks=estimated,
+        )
+        try:
+            result = await hook(ctx)
+        except Exception as e:
+            raise _OversizeHookFailure(e) from e
+        if result:
+            return result
+        return None
+
+    async def _create(
+        self,
+        receive_id: str,
+        receive_id_type: str,
+        body: Dict[str, str],
+        uuid_: str,
+    ) -> SendResult:
+        try:
+            raw = await _maybe_await(
+                self._driver.create_message(
+                    receive_id_type=receive_id_type,
+                    receive_id=receive_id,
+                    msg_type=body["msg_type"],
+                    content=body["content"],
+                    uuid=uuid_,
+                )
+            )
+        except Exception as e:
+            logger.exception("outbound: create_message raised: %s", e)
+            return SendResult.fail(SendError(code=FeishuChannelErrorCode.UNKNOWN, retryable=True, hint=str(e)))
+        result = self._to_result(raw)
+        if not result.success:
+            content_len = len(body.get("content", "") or "")
+            logger.warning(
+                "outbound: create_message FAILED receive_id_type=%s receive_id=%s msg_type=%s "
+                "request_content_len=%s response=%s",
+                receive_id_type, receive_id, body.get("msg_type"),
+                content_len,
+                result.raw,
+            )
+        return result
+
+    async def _reply(
+        self,
+        message_id: str,
+        body: Dict[str, str],
+        reply_in_thread: Optional[bool],
+        uuid_: str,
+    ) -> SendResult:
+        try:
+            kwargs: Dict[str, Any] = {
+                "message_id": message_id,
+                "msg_type": body["msg_type"],
+                "content": body["content"],
+                "uuid": uuid_,
+            }
+            if reply_in_thread is not None:
+                kwargs["reply_in_thread"] = reply_in_thread
+            raw = await _maybe_await(self._driver.reply_message(**kwargs))
+        except Exception as e:
+            logger.exception("outbound: reply_message raised: %s", e)
+            return SendResult.fail(SendError(code=FeishuChannelErrorCode.UNKNOWN, retryable=True, hint=str(e)))
+        result = self._to_result(raw)
+        if not result.success:
+            content_len = len(body.get("content", "") or "")
+            logger.warning(
+                "outbound: reply_message FAILED message_id=%s msg_type=%s "
+                "request_content_len=%s response=%s",
+                message_id, body.get("msg_type"),
+                content_len,
+                result.raw,
+            )
+        return result
+
+    def _to_result(self, raw: Any) -> SendResult:
+        resp = _unwrap(raw)
+        code = resp.get("code") or 0
+        if code == 0:
+            mid = _extract_message_id(resp)
+            if mid and self._on_success is not None:
+                try:
+                    self._on_success(mid)
+                except Exception as e:  # pragma: no cover - defensive
+                    logger.debug("outbound: _on_success hook raised: %s", e)
+            return SendResult.ok(message_id=mid, raw=resp)
+        return SendResult.fail(
+            classify_error(int(code), resp.get("msg") or ""),
+            raw=resp,
+        )
+
+
+def _post_to_plain_text_from_body(content: str) -> str:
+    """Extract a best-effort plain-text rendering from a post JSON body.
+
+    ``content`` is the already-serialised post body emitted by
+    :func:`_build_post`, i.e. ``{zh_cn: {title, content: [[...]]}}`` — NOT
+    wrapped in an outer ``{"post": ...}``. Used by the format_error → plain-
+    text downgrade path. Returns empty string on any structural mismatch.
+    """
+    try:
+        data = json.loads(content)
+        if not isinstance(data, dict) or not data:
+            return ""
+        locale = next(iter(data.values()))
+        if not isinstance(locale, dict):
+            return ""
+        out_lines: List[str] = []
+        title = locale.get("title")
+        if title:
+            out_lines.append(str(title))
+        for para in locale.get("content") or []:
+            pieces: List[str] = []
+            for el in para or []:
+                if not isinstance(el, dict):
+                    continue
+                if el.get("tag") == "text":
+                    pieces.append(el.get("text") or "")
+                elif el.get("tag") == "a":
+                    pieces.append(el.get("text") or el.get("href") or "")
+                elif el.get("tag") == "at":
+                    pieces.append(f"@{el.get('user_name') or el.get('user_id') or ''}")
+                elif el.get("tag") == "img":
+                    pieces.append("[image]")
+                elif el.get("tag") == "code_block":
+                    pieces.append(el.get("text") or "")
+            out_lines.append("".join(pieces))
+        return "\n".join(l for l in out_lines if l is not None).strip() or "[message]"
+    except Exception:
+        return ""
diff --git a/lark_channel/channel/outbound/streaming/__init__.py b/lark_channel/channel/outbound/streaming/__init__.py
new file mode 100644
index 0000000..92b9c4e
--- /dev/null
+++ b/lark_channel/channel/outbound/streaming/__init__.py
@@ -0,0 +1,7 @@
+"""Streaming primitives: throttle, update queue, and text-merge helpers."""
+
+from .merge_text import merge_streaming_text
+from .throttle import Throttle
+from .update_queue import UpdateQueue
+
+__all__ = ["Throttle", "UpdateQueue", "merge_streaming_text"]
diff --git a/lark_channel/channel/outbound/streaming/card_stream.py b/lark_channel/channel/outbound/streaming/card_stream.py
new file mode 100644
index 0000000..353bb5d
--- /dev/null
+++ b/lark_channel/channel/outbound/streaming/card_stream.py
@@ -0,0 +1,104 @@
+"""User-driven card streaming.
+
+The producer hands the controller a sequence of full card snapshots (or a
+transform function). Unlike `MarkdownStreamController`, which manages content
+string state, this variant gives the caller direct control over card JSON.
+
+Use case: complex cards with progress bars, timestamps, dynamic elements.
+"""
+
+from typing import Any, Awaitable, Callable, Dict, Union
+
+from lark_channel.core.log import logger
+
+from .throttle import Throttle
+from .update_queue import UpdateQueue
+
+
+STREAM_TERMINATED_FOOTER_ELEMENT = {
+    "tag": "markdown",
+    "content": "<font color='grey'>— generation interrupted</font>",
+}
+
+
+CardSnapshot = Union[Dict[str, Any], Callable[[Dict[str, Any]], Dict[str, Any]]]
+
+
+class CardStreamController:
+    def __init__(
+        self,
+        *,
+        initial: Dict[str, Any],
+        ensure_created: Callable[[Dict[str, Any]], Awaitable[str]],
+        patch_card: Callable[[str, Dict[str, Any]], Awaitable[Any]],
+        min_ms: int = 100,
+        min_chars: int = 50,
+    ) -> None:
+        self._ensure_created = ensure_created
+        self._patch_card = patch_card
+        self._current: Dict[str, Any] = dict(initial)
+        self._message_id = ""
+        self._queue = UpdateQueue()
+        self._throttle = Throttle(
+            min_ms=min_ms, min_chars=min_chars, on_fire=self._on_fire,
+        )
+
+    @property
+    def message_id(self) -> str:
+        return self._message_id
+
+    @property
+    def current(self) -> Dict[str, Any]:
+        return self._current
+
+    async def update(self, next_card: CardSnapshot) -> None:
+        await self._ensure_started()
+        if callable(next_card):
+            self._current = next_card(self._current)
+        else:
+            self._current = dict(next_card)
+        # Approximate delta size for throttle — roll up serialized length
+        import json as _json
+        approx = len(_json.dumps(self._current, ensure_ascii=False))
+        self._throttle.note(approx)
+
+    async def run(self, producer: Callable[["CardStreamController"], Awaitable[None]]) -> str:
+        import asyncio as _asyncio
+        try:
+            await producer(self)
+        except _asyncio.CancelledError:
+            raise
+        except Exception as e:
+            logger.warning("card stream: producer raised: %s", e)
+            self._throttle.dispose()
+            # Add a terminated footer element
+            body = self._current.setdefault("body", {"elements": []})
+            elements = body.setdefault("elements", [])
+            elements.append(STREAM_TERMINATED_FOOTER_ELEMENT)
+            await self._flush_final()
+            raise
+        self._throttle.flush_now()
+        await self._queue.drain()
+        return self._message_id
+
+    # ---- internals -----------------------------------------------------------
+    async def _ensure_started(self) -> None:
+        if self._message_id:
+            return
+        self._message_id = await self._ensure_created(self._current)
+
+    def _on_fire(self) -> None:
+        if not self._message_id:
+            return
+        snapshot = dict(self._current)
+        self._queue.enqueue(lambda: self._patch_card(self._message_id, snapshot))
+
+    async def _flush_final(self) -> None:
+        if not self._message_id:
+            try:
+                self._message_id = await self._ensure_created(self._current)
+            except Exception:
+                return
+        snapshot = dict(self._current)
+        self._queue.enqueue(lambda: self._patch_card(self._message_id, snapshot))
+        await self._queue.drain()
diff --git a/lark_channel/channel/outbound/streaming/markdown_stream.py b/lark_channel/channel/outbound/streaming/markdown_stream.py
new file mode 100644
index 0000000..ff72570
--- /dev/null
+++ b/lark_channel/channel/outbound/streaming/markdown_stream.py
@@ -0,0 +1,213 @@
+"""Markdown-centric streaming controller.
+
+Pre-allocates a CardKit card with a single markdown element, then ticks the
+element's content forward via sequenced ``update_card_element_content`` calls
+so out-of-order HTTP delivery cannot rewind visible content. On producer error
+the controller appends a terminated-footer, performs one final element update,
+drains the queue, calls ``finish_streaming_card``, and re-raises.
+
+Distinct from :class:`CardStreamController` (same directory), which accepts a
+full card JSON per tick and backs that with generic ``patch_card``.
+"""
+
+from typing import Any, Awaitable, Callable, Dict, Optional
+
+from lark_channel.core.log import logger
+
+from .merge_text import merge_streaming_text
+from .throttle import Throttle
+from .update_queue import UpdateQueue
+
+
+ELEMENT_ID = "stream_md"
+INITIAL_TEXT = "Thinking..."
+TERMINATED_FOOTER = "\n\n— _(generation interrupted)_"
+
+
+# Public type aliases for the 4 cardkit dependencies the controller needs.
+CreateCardInstance = Callable[[Dict[str, Any]], Awaitable[str]]
+SendCardByReference = Callable[..., Awaitable[Any]]
+UpdateCardElementContent = Callable[[str, str, str, int], Awaitable[None]]
+FinishStreamingCard = Callable[[str, int], Awaitable[None]]
+
+
+class MarkdownStreamController:
+    """User-facing controller passed to the producer closure.
+
+    ``append()`` / ``set_content()`` are the only two methods the producer
+    calls. Everything else is plumbing invoked from :class:`FeishuChannel`.
+    """
+
+    def __init__(
+        self,
+        *,
+        to: str,
+        receive_id_type: str,
+        reply_to: Optional[str],
+        reply_in_thread: Optional[bool],
+        create_card_instance: CreateCardInstance,
+        send_card_by_reference: SendCardByReference,
+        update_card_element_content: UpdateCardElementContent,
+        finish_streaming_card: FinishStreamingCard,
+        reply_target_gone: str = "fresh",
+        min_ms: int = 100,
+        min_chars: int = 50,
+        initial_text: str = INITIAL_TEXT,
+        element_id: str = ELEMENT_ID,
+    ) -> None:
+        self._to = to
+        self._rit = receive_id_type
+        self._reply_to = reply_to
+        self._reply_in_thread = reply_in_thread
+        self._reply_target_gone = reply_target_gone
+        self._create_card_instance = create_card_instance
+        self._send_card_by_reference = send_card_by_reference
+        self._update_card_element_content = update_card_element_content
+        self._finish_streaming_card = finish_streaming_card
+        self._initial_text = initial_text
+        self._element_id = element_id
+
+        self._card_id: Optional[str] = None
+        self._message_id: str = ""
+        self._sequence: int = 0
+        self._content: str = ""
+
+        self._queue = UpdateQueue()
+        self._throttle = Throttle(
+            min_ms=min_ms,
+            min_chars=min_chars,
+            on_fire=self._on_fire,
+        )
+
+    @property
+    def message_id(self) -> str:
+        return self._message_id
+
+    @property
+    def card_id(self) -> Optional[str]:
+        return self._card_id
+
+    # ---- producer-facing API -------------------------------------------------
+    async def append(self, chunk: str) -> None:
+        if not chunk:
+            return
+        await self._ensure_started()
+        new_content = merge_streaming_text(self._content, chunk)
+        delta = len(new_content) - len(self._content)
+        self._content = new_content
+        self._throttle.note(max(1, delta))
+
+    async def set_content(self, full: str) -> None:
+        await self._ensure_started()
+        self._content = full or ""
+        # Force immediate flush — mirrors node passing MAX_SAFE_INTEGER.
+        self._throttle.flush_now()
+
+    async def run(
+        self, producer: Callable[["MarkdownStreamController"], Awaitable[None]]
+    ) -> str:
+        """Drive the producer; return the message_id.
+
+        Success path: drain queue → ``finish_streaming_card``.
+        Error path: append footer → push one final update → drain →
+        ``finish_streaming_card`` → re-raise.
+        """
+        import asyncio as _asyncio
+
+        try:
+            await producer(self)
+        except _asyncio.CancelledError:
+            raise
+        except Exception as e:
+            logger.warning("markdown-stream: producer raised: %s", e)
+            await self._fail_terminal()
+            raise
+        await self._complete_terminal()
+        return self._message_id
+
+    # ---- internals -----------------------------------------------------------
+    async def _ensure_started(self) -> None:
+        if self._card_id:
+            return
+        spec = {
+            "schema": "2.0",
+            "config": {"streaming_mode": True, "summary": {"content": ""}},
+            "body": {
+                "elements": [
+                    {
+                        "tag": "markdown",
+                        "element_id": self._element_id,
+                        "content": self._initial_text,
+                    }
+                ]
+            },
+        }
+        self._card_id = await self._create_card_instance(spec)
+        kwargs = {
+            "receive_id_type": self._rit,
+            "reply_to": self._reply_to,
+            "reply_in_thread": self._reply_in_thread,
+        }
+        if self._reply_target_gone != "fresh":
+            kwargs["reply_target_gone"] = self._reply_target_gone
+        result = await self._send_card_by_reference(
+            self._to,
+            self._card_id,
+            **kwargs,
+        )
+        self._message_id = getattr(result, "message_id", "") or ""
+
+    def _on_fire(self) -> None:
+        """Throttle callback: snapshot content, stamp seq, enqueue update."""
+        if not self._card_id:
+            return
+        self._sequence += 1
+        seq = self._sequence
+        text = self._content or "..."
+        card_id = self._card_id
+        element_id = self._element_id
+        self._queue.enqueue(
+            lambda: self._update_card_element_content(card_id, element_id, text, seq)
+        )
+
+    async def _complete_terminal(self) -> None:
+        # Flush any pending throttle work first.
+        self._throttle.flush_now()
+        await self._queue.drain()
+        if self._card_id:
+            self._sequence += 1
+            try:
+                await self._finish_streaming_card(self._card_id, self._sequence)
+            except Exception as e:  # pragma: no cover
+                logger.warning(
+                    "markdown-stream: finish_streaming_card failed: %s", e
+                )
+
+    async def _fail_terminal(self) -> None:
+        # If the card never got created (producer raised before first append),
+        # synthesize it so the user at least sees the error footer.
+        if not self._card_id:
+            try:
+                await self._ensure_started()
+            except Exception:  # pragma: no cover
+                return
+        self._throttle.dispose()
+        self._content = (self._content or "") + TERMINATED_FOOTER
+
+        self._sequence += 1
+        seq = self._sequence
+        card_id = self._card_id
+        element_id = self._element_id
+        text = self._content
+        self._queue.enqueue(
+            lambda: self._update_card_element_content(card_id, element_id, text, seq)
+        )
+        await self._queue.drain()
+
+        self._sequence += 1
+        try:
+            await self._finish_streaming_card(self._card_id, self._sequence)
+        except Exception as e:  # pragma: no cover
+            logger.warning(
+                "markdown-stream: finish_streaming_card (error path) failed: %s", e
+            )
diff --git a/lark_channel/channel/outbound/streaming/merge_text.py b/lark_channel/channel/outbound/streaming/merge_text.py
new file mode 100644
index 0000000..161d44a
--- /dev/null
+++ b/lark_channel/channel/outbound/streaming/merge_text.py
@@ -0,0 +1,35 @@
+"""Smart concat for streaming text deltas.
+
+Different streaming producers yield text in different ways:
+- **Delta**: each chunk is a new suffix (`"Hello"` → `" world"`).
+- **Accumulated**: each chunk is the running total
+  (`"Hello"` → `"Hello world"`).
+- **Mixed** — some frameworks switch styles mid-stream.
+
+`merge_streaming_text(prev, next)` handles all three:
+
+    if next startswith prev:   # accumulated; use next
+        return next
+    if prev startswith next:   # producer rewound; keep prev
+        return prev
+    # else: compute the largest suffix of prev that is also a prefix of next,
+    # drop that prefix from next, and concatenate.
+"""
+
+
+def merge_streaming_text(prev: str, chunk: str) -> str:
+    if not chunk:
+        return prev
+    if not prev:
+        return chunk
+    if chunk.startswith(prev):
+        return chunk
+    if prev.startswith(chunk):
+        return prev
+
+    # Find the longest suffix of prev that is a prefix of chunk.
+    max_overlap = min(len(prev), len(chunk))
+    for size in range(max_overlap, 0, -1):
+        if prev[-size:] == chunk[:size]:
+            return prev + chunk[size:]
+    return prev + chunk
diff --git a/lark_channel/channel/outbound/streaming/throttle.py b/lark_channel/channel/outbound/streaming/throttle.py
new file mode 100644
index 0000000..fa6e337
--- /dev/null
+++ b/lark_channel/channel/outbound/streaming/throttle.py
@@ -0,0 +1,87 @@
+"""Dual-threshold throttle: fire on (ms_elapsed >= min_ms) OR (pending >= chars).
+
+Exposes three methods:
+
+- `note(delta_chars)` — record that new content arrived; may schedule or fire
+- `flush_now()` — force-fire immediately
+- `dispose()` — cancel pending timers
+
+`on_fire` is the flush callback (sync; caller ensures it enqueues, not blocks).
+"""
+
+import asyncio
+import time
+from typing import Callable, Optional
+
+
+class Throttle:
+    def __init__(
+        self,
+        *,
+        min_ms: int = 100,
+        min_chars: int = 50,
+        on_fire: Callable[[], None],
+    ) -> None:
+        self._min_ms = min_ms
+        self._min_chars = min_chars
+        self._on_fire = on_fire
+        self._pending_chars = 0
+        self._last_fire_ms = 0
+        self._timer: Optional[asyncio.TimerHandle] = None
+        self._running = False
+
+    def note(self, delta_chars: int) -> None:
+        self._pending_chars += max(0, delta_chars)
+        if self._running:
+            return  # a fire is already in flight; the current `on_fire` will sweep
+        if self._pending_chars >= self._min_chars:
+            self._cancel_timer()
+            self._do_fire()
+            return
+        if self._timer is not None:
+            return
+        now = _now_ms()
+        elapsed = now - self._last_fire_ms
+        wait_ms = max(0, self._min_ms - elapsed)
+        loop = asyncio.get_running_loop()
+        self._timer = loop.call_later(wait_ms / 1000.0, self._do_fire)
+
+    def flush_now(self) -> None:
+        self._cancel_timer()
+        self._do_fire()
+
+    def dispose(self) -> None:
+        self._cancel_timer()
+
+    # ---- internals ----------------------------------------------------------
+    def _do_fire(self) -> None:
+        # Clear timer/state BEFORE the synchronous ``on_fire`` call — if the
+        # callback triggers a re-entrant ``note`` (unusual but legal) we want
+        # the state consistent for that call, and we don't want
+        # ``self._timer`` to still look "pending" during the fire.
+        self._timer = None
+        self._pending_chars = 0
+        self._last_fire_ms = _now_ms()
+        self._running = True
+        try:
+            self._on_fire()
+        finally:
+            # ``_running`` guards re-entry into ``on_fire`` from a synchronous
+            # ``note`` called inside the fire callback; the actual HTTP work
+            # runs off in ``UpdateQueue`` so nothing is "in flight" from our
+            # perspective once ``on_fire`` returns.
+            self._running = False
+
+    def _cancel_timer(self) -> None:
+        if self._timer is not None:
+            try:
+                self._timer.cancel()
+            except Exception:  # pragma: no cover
+                pass
+            self._timer = None
+
+
+def _now_ms() -> int:
+    # ``time.monotonic`` is immune to NTP steps + DST jumps; ``time.time`` is
+    # not. For an interval-based throttle, the former is always correct.
+    return int(time.monotonic() * 1000)
diff --git a/lark_channel/channel/outbound/streaming/update_queue.py b/lark_channel/channel/outbound/streaming/update_queue.py
new file mode 100644
index 0000000..c50c3d4
--- /dev/null
+++ b/lark_channel/channel/outbound/streaming/update_queue.py
@@ -0,0 +1,103 @@
+"""Coalescing task queue for streaming card updates.
+
+Semantics: at any time, **at most one task runs and at most one task is
+pending**. When a new task is enqueued while another is still pending
+(queued but not yet started), the new one **replaces** the pending task —
+only the most recent snapshot survives. If a task is currently running,
+the new enqueue becomes the new pending; when the running task finishes,
+it chains the pending task.
+
+This matches the streaming-card use case where each enqueued task is a
+snapshot of the current accumulated content. Only the latest snapshot
+matters for user-visible state:
+
+- ``MarkdownStreamController`` uses the server-sequenced element-update
+  API (``update_card_element_content(card_id, elem_id, content, seq)``).
+  The server orders updates by ``seq``; dropping an intermediate client-
+  side task simply skips one round-trip — the next (latest) task still
+  carries a higher seq and ends up winning.
+- ``CardStreamController`` uses the non-sequenced ``patch_card`` API.
+  Coalescing guarantees at most one HTTP is in flight at a time, so
+  client-side serial execution is sufficient ordering.
+
+**Intentional divergence from node-sdk**: node's ``UpdateQueue`` is a
+strict FIFO that serializes *every* enqueued task. Python coalesces —
+fewer HTTP calls under fast producers, no change to final state, but a
+caller observing HTTP traffic will see fewer intermediate states in
+Python than in node. Documented in the channel README.
+
+Failure handling: a task exception is logged but NOT retried. The next
+``enqueue`` naturally supersedes. Callers (e.g. ``MarkdownStreamController``)
+should flush a final-state task in their terminal path so the user sees
+complete content even if an intermediate update failed.
+"""
+
+import asyncio
+from typing import Any, Awaitable, Callable, Optional
+
+from lark_channel.core.log import logger
+
+
+class UpdateQueue:
+    """Coalescing queue: at most 1 running + 1 pending task at any time."""
+
+    def __init__(self) -> None:
+        self._running: Optional[asyncio.Task] = None
+        self._pending: Optional[Callable[[], Awaitable[Any]]] = None
+
+    def enqueue(self, task: Callable[[], Awaitable[Any]]) -> None:
+        """Schedule ``task``. If a task is pending (not yet started), it is
+        silently replaced — only the latest survives.
+
+        Returns nothing: callers cannot rely on the task running, since it
+        may be superseded before start. Await :meth:`drain` to wait for
+        the queue to quiesce.
+        """
+        self._pending = task
+        if self._running is None or self._running.done():
+            self._start_next()
+
+    async def drain(self) -> None:
+        """Wait until the queue is fully idle.
+
+        Iterates because each running task, upon completion, may chain a
+        pending task in its ``finally`` block — so we must re-check the
+        tail state after awaiting.
+
+        ``CancelledError`` propagates — a caller cancelling the drainer is
+        a signal we should not absorb. Other exceptions are swallowed after
+        being logged inside ``_runner`` so we can continue draining.
+        """
+        while self._running is not None and not self._running.done():
+            try:
+                await self._running
+            except asyncio.CancelledError:
+                raise
+            except Exception:
+                # Failures are already logged in _runner; keep draining.
+                pass
+
+    # ---- internals ----------------------------------------------------------
+    def _start_next(self) -> None:
+        """Claim `_pending` and kick off its task. Called from `enqueue` and
+        from inside a completing task's `finally` block."""
+        if self._pending is None:
+            self._running = None
+            return
+        task = self._pending
+        self._pending = None
+        loop = asyncio.get_running_loop()
+
+        async def _runner() -> None:
+            try:
+                await task()
+            except asyncio.CancelledError:
+                raise
+            except Exception as e:
+                logger.warning("UpdateQueue: task failed: %s", e)
+            finally:
+                # Chain the next pending (if any new enqueue happened while
+                # we were running). Single-threaded asyncio means no race.
+                self._start_next()
+
+        self._running = loop.create_task(_runner())
diff --git a/lark_channel/channel/quote.py b/lark_channel/channel/quote.py
new file mode 100644
index 0000000..e48f9bf
--- /dev/null
+++ b/lark_channel/channel/quote.py
@@ -0,0 +1,168 @@
+import inspect
+import json
+from typing import Any, Callable, Dict, Iterable, List, Optional
+
+from .types import InboundMessage, QuoteResolution, QuotedContext
+
+
+class QuoteResolver:
+    def __init__(self, *, fetcher: Callable[[str], Any]) -> None:
+        self._fetcher = fetcher
+
+    async def fetch_quoted_context(self, message_id: str) -> Optional[QuotedContext]:
+        try:
+            raw = self._fetcher(message_id)
+            if inspect.isawaitable(raw):
+                raw = await raw
+        except Exception:
+            return None
+        raw = _object_to_dict(raw)
+        if not isinstance(raw, dict):
+            return None
+        code = raw.get("code")
+        if code is not None and code != 0:
+            return None
+        return _context_from_raw(message_id, raw)
+
+    async def resolve_quoted_contexts(
+        self,
+        messages: Iterable[InboundMessage],
+        *,
+        chat_mode: Optional[str],
+    ) -> Dict[str, QuoteResolution]:
+        batch = list(messages)
+        batch_ids = {msg.id for msg in batch}
+        parent_ids: List[str] = []
+        results: Dict[str, QuoteResolution] = {}
+
+        for msg in batch:
+            parent_id = msg.reply.message_id if msg.reply else None
+            root_id = _message_raw_field(msg.raw, "root_id")
+            if not parent_id:
+                results[msg.id] = QuoteResolution(msg.id, None, "no_parent")
+            elif chat_mode in ("topic", "thread") and parent_id == root_id:
+                results[msg.id] = QuoteResolution(msg.id, parent_id, "topic_root")
+            elif parent_id in batch_ids:
+                results[msg.id] = QuoteResolution(msg.id, parent_id, "in_batch")
+            else:
+                results[msg.id] = QuoteResolution(msg.id, parent_id, "fetch_failed")
+                if parent_id not in parent_ids:
+                    parent_ids.append(parent_id)
+
+        fetched = {}
+        for parent_id in parent_ids:
+            fetched[parent_id] = await self.fetch_quoted_context(parent_id)
+
+        for msg in batch:
+            current = results[msg.id]
+            parent_id = current.parent_message_id
+            if (
+                current.decision == "fetch_failed"
+                and parent_id in fetched
+                and fetched[parent_id] is not None
+            ):
+                results[msg.id] = QuoteResolution(
+                    msg.id,
+                    parent_id,
+                    "resolved",
+                    fetched[parent_id],
+                )
+        return results
+
+
+def _context_from_raw(message_id: str, raw: Dict[str, Any]) -> QuotedContext:
+    data = raw.get("data") if isinstance(raw.get("data"), dict) else raw
+    item = _first_message_item(data)
+    body = item.get("body") if isinstance(item.get("body"), dict) else {}
+    content = _decode_content(
+        body.get("content") if body.get("content") is not None else item.get("content")
+    )
+    sender = _object_to_dict(item.get("sender") or {})
+    return QuotedContext(
+        message_id=item.get("message_id") or message_id,
+        text=_flatten_content(content),
+        sender_id=_sender_id(sender),
+        create_time=_as_int(item.get("create_time")),
+        content_type=item.get("msg_type") or item.get("message_type"),
+        raw=item,
+    )
+
+
+def _first_message_item(raw: Dict[str, Any]) -> Dict[str, Any]:
+    items = raw.get("items")
+    if isinstance(items, list) and items and isinstance(items[0], dict):
+        return items[0]
+    return raw
+
+
+def _message_raw_field(raw: Dict[str, Any], key: str) -> Any:
+    if not isinstance(raw, dict):
+        return None
+    nested = raw.get("message")
+    if isinstance(nested, dict) and nested.get(key) is not None:
+        return nested.get(key)
+    return raw.get(key)
+
+
+def _sender_id(sender: Dict[str, Any]) -> Optional[str]:
+    if not isinstance(sender, dict):
+        return None
+    return (
+        sender.get("open_id")
+        or sender.get("user_id")
+        or sender.get("union_id")
+        or sender.get("id")
+    )
+
+
+def _decode_content(content: Any) -> Any:
+    if isinstance(content, str):
+        try:
+            return json.loads(content)
+        except ValueError:
+            return {"text": content}
+    return content or {}
+
+
+def _flatten_content(content: Any) -> str:
+    if isinstance(content, dict):
+        parts: List[str] = []
+        for key in ("text", "title", "content", "summary"):
+            value = content.get(key)
+            if isinstance(value, str) and value:
+                parts.append(value)
+            elif isinstance(value, (dict, list)):
+                nested = _flatten_content(value)
+                if nested:
+                    parts.append(nested)
+        for key in ("elements", "blocks", "items", "messages"):
+            value = content.get(key)
+            if isinstance(value, list):
+                parts.extend(part for part in (_flatten_content(item) for item in value) if part)
+        return "\n".join(part for part in parts if part)
+    if isinstance(content, list):
+        return "\n".join(part for part in (_flatten_content(item) for item in content) if part)
+    return str(content) if content else ""
+
+
+def _object_to_dict(value: Any) -> Any:
+    if isinstance(value, dict):
+        return {key: _object_to_dict(val) for key, val in value.items()}
+    if isinstance(value, list):
+        return [_object_to_dict(item) for item in value]
+    if hasattr(value, "__dict__"):
+        return {
+            key: _object_to_dict(val)
+            for key, val in value.__dict__.items()
+            if not key.startswith("_")
+        }
+    return value
+
+
+def _as_int(value: Any) -> Optional[int]:
+    if value is None:
+        return None
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return None
diff --git a/lark_channel/channel/safety/__init__.py b/lark_channel/channel/safety/__init__.py
new file mode 100644
index 0000000..8882647
--- /dev/null
+++ b/lark_channel/channel/safety/__init__.py
@@ -0,0 +1,37 @@
+"""Safety pipeline — dedup, stale detection, policy, lock, batch+queue."""
+
+from .chat_pipeline import ChatPipeline, ChatPipelineManager, merge_batch
+from .pipeline import SafetyPipeline
+from .policy_gate import PolicyDecision, PolicyGate
+from .processing_lock import ProcessingLock
+from .dedup_cache import SeenCache
+from .stale_detector import DEFAULT_STALE_MS, is_stale
+from .types import (
+    BatchConfig,
+    ChatQueueConfig,
+    DedupConfig,
+    MediaBatchConfig,
+    RejectEvent,
+    RejectReason,
+    TextBatchConfig,
+)
+
+__all__ = [
+    "BatchConfig",
+    "ChatPipeline",
+    "ChatPipelineManager",
+    "ChatQueueConfig",
+    "DEFAULT_STALE_MS",
+    "DedupConfig",
+    "MediaBatchConfig",
+    "PolicyDecision",
+    "PolicyGate",
+    "ProcessingLock",
+    "RejectEvent",
+    "RejectReason",
+    "SafetyPipeline",
+    "SeenCache",
+    "TextBatchConfig",
+    "is_stale",
+    "merge_batch",
+]
diff --git a/lark_channel/channel/safety/chat_pipeline.py b/lark_channel/channel/safety/chat_pipeline.py
new file mode 100644
index 0000000..8c62a95
--- /dev/null
+++ b/lark_channel/channel/safety/chat_pipeline.py
@@ -0,0 +1,371 @@
+"""Per-chat batch aggregation + serial handler execution.
+
+Problem solved: a user firing rapid-fire messages ("help" / "write a" /
+"quicksort") should be treated as ONE request, not three. Also: we must
+never run two handlers concurrently for the same chat (races on shared
+conversation state).
+
+`ChatPipeline` owns both responsibilities for a given scope (usually chat_id
+or file_token):
+
+- **Batch**: incoming messages go into a buffer; a debounce timer fires after
+  `delay_ms` (or `long_delay_ms` if accumulated chars ≥ `long_threshold_chars`).
+  The timer, `max_messages`, and `max_chars` are three parallel flush triggers.
+- **Serialize**: flushes are enqueued on a single task chain so a slow handler
+  blocks later flushes in the same scope.
+
+`ChatPipelineManager` is a keyed registry — one pipeline per chat_id.
+"""
+
+import asyncio
+from typing import Any, Awaitable, Callable, Dict, List, Optional, Tuple
+
+from ..types import InboundMessage
+from .types import ChatQueueConfig, TextBatchConfig
+
+FlushHandler = Callable[[InboundMessage, List[InboundMessage]], Awaitable[None]]
+
+
+def merge_batch(batch: List[InboundMessage]) -> InboundMessage:
+    """Merge a batch of inbound messages into a single virtual message.
+
+    The last message's metadata (id, sender, timestamps) wins; `content.text`
+    is joined with `\\n\\n`; mentions and raw are unified.
+    """
+    if len(batch) == 1:
+        return batch[0]
+    last = batch[-1]
+    texts: List[str] = []
+    all_mentions = list(last.mentions or [])
+    mentioned_all = False
+    mentioned_bot = False
+    chat_mode = last.chat_mode
+    seen_mention_ids = set()
+    for m in batch:
+        content = m.content
+        text = getattr(content, "text", "") or getattr(content, "title", "") or ""
+        if text:
+            texts.append(text)
+        if m.mentioned_all:
+            mentioned_all = True
+        if m.mentioned_bot:
+            mentioned_bot = True
+        if chat_mode is None and m.chat_mode is not None:
+            chat_mode = m.chat_mode
+        for mention in m.mentions or []:
+            sig = mention.open_id or mention.user_id or mention.key
+            if sig in seen_mention_ids:
+                continue
+            seen_mention_ids.add(sig)
+            if mention not in all_mentions:
+                all_mentions.append(mention)
+    from ..types import InboundMessage as _IM, TextContent
+
+    merged_content = last.content
+    if isinstance(merged_content, TextContent) and texts:
+        merged_content = TextContent(text="\n\n".join(texts), raw=merged_content.raw)
+    merged = _IM(
+        id=last.id,
+        create_time=last.create_time,
+        conversation=last.conversation,
+        sender=last.sender,
+        mentions=all_mentions,
+        mentioned_all=mentioned_all or last.mentioned_all,
+        mentioned_bot=mentioned_bot or last.mentioned_bot,
+        reply=last.reply,
+        content=merged_content,
+        raw=last.raw,
+        chat_mode=chat_mode,
+    )
+    return merged
+
+
+class ChatPipeline:
+    """Single-scope batch + serialize pipeline.
+
+    Two modes:
+    - `serial_only=False` (default): full batch + serialize. Used for messages.
+    - `serial_only=True`: no batching; `run(task)` chains tasks FIFO. Used for
+      cardAction / comment.
+    """
+
+    def __init__(
+        self,
+        scope: str,
+        config: TextBatchConfig,
+        loop: asyncio.AbstractEventLoop,
+        *,
+        serial_only: bool = False,
+        merge_while_busy: bool = True,
+    ) -> None:
+        self._scope = scope
+        self._config = config
+        self._loop = loop
+        self._serial_only = serial_only
+        self._merge_while_busy = merge_while_busy
+
+        self._buffer: List[InboundMessage] = []
+        self._buffer_chars = 0
+        self._blocked_batches: List[Tuple[List[InboundMessage], FlushHandler]] = []
+        self._timer: Optional[asyncio.TimerHandle] = None
+        self._pending_handler: Optional[FlushHandler] = None
+        self._tail: asyncio.Task = self._loop.create_task(self._noop())
+        self._blocked = False
+        self._deferred_runs: List[Tuple[Callable[[], Awaitable[Any]], asyncio.Future]] = []
+
+    async def _noop(self) -> None:
+        return None
+
+    # ---- message batch path --------------------------------------------------
+    def push(self, msg: InboundMessage, handler: FlushHandler) -> None:
+        """Buffer a message and arm the debounce timer."""
+        if self._blocked and not self._merge_while_busy:
+            self._blocked_batches.append(([msg], handler))
+            return
+
+        self._buffer.append(msg)
+        text = getattr(msg.content, "text", "") or ""
+        self._buffer_chars += len(text)
+        if self._pending_handler is None:
+            self._pending_handler = handler
+
+        if self._blocked:
+            return
+
+        # Flush on caps
+        if self._should_flush_for_caps():
+            self._flush_now()
+            return
+
+        self._schedule_timer()
+
+    def block(self) -> None:
+        self._blocked = True
+        self._cancel_timer()
+
+    def unblock(self) -> None:
+        self._blocked = False
+        if self._blocked_batches:
+            if self._buffer:
+                self._cancel_timer()
+                self._flush_async(release_deferred=False)
+            self._flush_blocked_batches()
+            return
+        if self._buffer:
+            if self._should_flush_for_caps():
+                self._flush_now()
+                return
+            self._schedule_timer()
+
+    def cancel_buffer(self) -> None:
+        self._cancel_timer()
+        self._buffer = []
+        self._buffer_chars = 0
+        self._blocked_batches = []
+        self._pending_handler = None
+        self._release_deferred_runs()
+
+    def enable_batching(self) -> None:
+        self._serial_only = False
+
+    def _flush_async(self, *, release_deferred: bool = True) -> None:
+        if not self._buffer:
+            if release_deferred and not self._blocked_batches:
+                self._release_deferred_runs()
+            return
+        batch = self._buffer
+        handler = self._pending_handler
+        self._buffer = []
+        self._buffer_chars = 0
+        self._pending_handler = None
+        if handler is None:
+            if release_deferred:
+                self._release_deferred_runs()
+            return
+        merged = merge_batch(batch)
+        self._enqueue(lambda: handler(merged, batch))
+        if release_deferred:
+            self._release_deferred_runs()
+
+    def _flush_blocked_batches(self) -> None:
+        if not self._blocked_batches:
+            self._release_deferred_runs()
+            return
+        batches = self._blocked_batches
+        self._blocked_batches = []
+        for batch, handler in batches:
+            merged = merge_batch(batch)
+            self._enqueue(
+                lambda h=handler, m=merged, b=batch: h(m, b)
+            )
+        self._release_deferred_runs()
+
+    # ---- free-standing serialize path ---------------------------------------
+    def run(self, task: Callable[[], Awaitable[Any]]) -> "asyncio.Future[Any]":
+        """Chain a task onto the serial queue; returns a future for its result."""
+        # Force any pending buffered batch to flush first. While blocked, keep
+        # later same-scope work behind the buffered batch until it is released.
+        if self._blocked and (self._buffer or self._blocked_batches):
+            fut = self._loop.create_future()
+            self._deferred_runs.append((task, fut))
+            return fut
+        if self._buffer:
+            self._cancel_timer()
+            self._flush_async()
+        return self._enqueue(task)
+
+    # ---- internals -----------------------------------------------------------
+    def _enqueue(self, task: Callable[[], Awaitable[Any]]) -> "asyncio.Future[Any]":
+        prev_tail = self._tail
+
+        async def runner():
+            # ``prev_tail`` is captured via closure. Without the ``nonlocal``
+            # + explicit ``prev_tail = None`` below, each runner would hold a
+            # reference to its predecessor for its entire lifetime, and a
+            # long chat-history serialization chain (one runner per message
+            # in a busy group) would keep every completed ancestor alive in
+            # memory until the whole chain drains. Clearing the closure cell
+            # as soon as we're past the await lets Python reap ancestors
+            # eagerly.
+            nonlocal prev_tail
+            if prev_tail is not None:
+                try:
+                    await prev_tail
+                except asyncio.CancelledError:
+                    raise
+                except Exception:  # prior task failure shouldn't block us
+                    pass
+            prev_tail = None  # drop the closure's grip on the previous task
+            return await task()
+
+        next_task = self._loop.create_task(runner())
+        self._tail = next_task
+        return next_task
+
+    def _release_deferred_runs(self) -> None:
+        if not self._deferred_runs:
+            return
+        deferred = self._deferred_runs
+        self._deferred_runs = []
+        for task, outer in deferred:
+            if outer.cancelled():
+                continue
+            inner = self._enqueue(task)
+
+            def _complete(
+                f: "asyncio.Future[Any]",
+                target: "asyncio.Future[Any]" = outer,
+            ) -> None:
+                if target.cancelled():
+                    return
+                try:
+                    target.set_result(f.result())
+                except asyncio.CancelledError:
+                    target.cancel()
+                except Exception as e:
+                    target.set_exception(e)
+
+            inner.add_done_callback(_complete)
+
+    def _cancel_timer(self) -> None:
+        if self._timer is not None:
+            try:
+                self._timer.cancel()
+            except Exception:  # pragma: no cover - defensive
+                pass
+            self._timer = None
+
+    def _should_flush_for_caps(self) -> bool:
+        return (
+            len(self._buffer) >= self._config.max_messages
+            or self._buffer_chars >= self._config.max_chars
+        )
+
+    def _flush_now(self) -> None:
+        self._cancel_timer()
+        self._flush_async()
+
+    def _schedule_timer(self) -> None:
+        # delayMs=0 or serial_only → immediate flush
+        if self._config.delay_ms <= 0 or self._serial_only:
+            self._flush_now()
+            return
+
+        # Debounce: long messages get longer delay
+        delay_ms = (
+            self._config.long_delay_ms
+            if self._buffer_chars >= self._config.long_threshold_chars
+            else self._config.delay_ms
+        )
+        self._cancel_timer()
+        self._timer = self._loop.call_later(delay_ms / 1000.0, self._flush_async)
+
+    async def dispose(self) -> None:
+        """Flush any buffered batch and wait for outstanding tasks."""
+        self._cancel_timer()
+        if self._buffer:
+            self._flush_async(release_deferred=not self._blocked_batches)
+        if self._blocked_batches:
+            self._flush_blocked_batches()
+        elif not self._buffer:
+            self._release_deferred_runs()
+        try:
+            await self._tail
+        except (asyncio.CancelledError, Exception):
+            pass
+
+
+class ChatPipelineManager:
+    """Map of scope → ChatPipeline, lazily created."""
+
+    def __init__(
+        self,
+        config: TextBatchConfig,
+        loop: asyncio.AbstractEventLoop,
+        queue_config: Optional[ChatQueueConfig] = None,
+    ) -> None:
+        self._config = config
+        self._loop = loop
+        queue_config = queue_config or ChatQueueConfig()
+        self._queue_enabled = queue_config.enabled
+        self._merge_while_busy = queue_config.merge_while_busy
+        self._pipelines: Dict[str, ChatPipeline] = {}
+
+    def push(self, scope: str, msg: InboundMessage, handler: FlushHandler) -> None:
+        self._pipeline(scope, serial_only=False).push(msg, handler)
+
+    def run(self, scope: str, task: Callable[[], Awaitable[Any]]) -> "asyncio.Future[Any]":
+        return self._pipeline(scope, serial_only=True).run(task)
+
+    def block_scope(self, scope: str) -> None:
+        self._pipeline(scope, serial_only=False).block()
+
+    def unblock_scope(self, scope: str) -> None:
+        self._pipeline(scope, serial_only=False).unblock()
+
+    def cancel_scope(self, scope: str) -> None:
+        self._pipeline(scope, serial_only=False).cancel_buffer()
+
+    def _pipeline(self, scope: str, *, serial_only: bool) -> ChatPipeline:
+        pipeline = self._pipelines.get(scope)
+        if pipeline is None:
+            pipeline = ChatPipeline(
+                scope,
+                self._config,
+                self._loop,
+                serial_only=serial_only,
+                merge_while_busy=self._merge_while_busy,
+            )
+            self._pipelines[scope] = pipeline
+        elif not serial_only:
+            pipeline.enable_batching()
+        return pipeline
+
+    async def dispose(self) -> None:
+        for pipeline in list(self._pipelines.values()):
+            await pipeline.dispose()
+        self._pipelines.clear()
+
+    @property
+    def queue_enabled(self) -> bool:
+        return self._queue_enabled
diff --git a/lark_channel/channel/safety/dedup_cache.py b/lark_channel/channel/safety/dedup_cache.py
new file mode 100644
index 0000000..4e01812
--- /dev/null
+++ b/lark_channel/channel/safety/dedup_cache.py
@@ -0,0 +1,144 @@
+"""Two-tier dedup cache: in-memory LRU + optional shared Cache.
+
+- **Memory layer** (default): bounded LRU + TTL, no external dependencies, no
+  cross-process coherence.
+- **Cache layer** (optional): pluggable `lark_channel.core.cache.ICache` — usually
+  Redis-backed. Lets multiple agent workers share dedup state, and survives
+  restarts.
+
+`has(id)` reads memory first; on miss it consults the Cache layer and
+back-fills memory if the Cache layer has a hit. `add(id)` writes both.
+
+**Concurrency caveat — single-process dedup is not atomic across workers.**
+``has`` + ``add`` is a check-then-act sequence; two concurrent callers for
+the same event id may both observe "not seen" and both proceed to the
+handler. The in-process :class:`~.processing_lock.ProcessingLock` breaks
+the tie within a single process, but does **not** cross process boundaries.
+
+If you run multiple agent workers behind a shared ``ICache`` (e.g. Redis),
+the current ``ICache`` interface does not expose an atomic SETNX primitive,
+so cross-process duplicate delivery is possible for a short window. The
+safe patterns are:
+
+1. **Single worker per app_id.** Route all events for one Feishu app to a
+   single process (sticky routing / leader election). This is the default
+   assumption and the only configuration fully covered by the tests.
+2. **Idempotent handlers.** If you must run multiple workers, design your
+   event handlers to be idempotent on the event id.
+
+A future version may add ``ICache.set_if_not_exists`` so the cache layer
+itself can serialize concurrent first-writers; until then, treat the cache
+layer as a best-effort speedup, not a coherence boundary.
+"""
+
+import threading
+import time
+from collections import OrderedDict
+from typing import Optional
+
+from lark_channel.core.cache import ICache
+from lark_channel.core.log import logger
+
+DEFAULT_TTL_SECONDS = 12 * 3600
+DEFAULT_MAX_ENTRIES = 5000
+DEFAULT_SWEEP_SECONDS = 5 * 60
+DEFAULT_NAMESPACE = "channel:seen:"
+
+
+class SeenCache:
+    """Thread-safe two-layer dedup cache.
+
+    Use `has_sync` / `add_sync` for purely in-memory use; the async variants
+    also consult / write the injected `ICache`. Both APIs coexist because the
+    underlying `ICache` is synchronous, but we may later plug in an async
+    Redis client — the async signatures keep that upgrade path open without
+    breaking callers.
+    """
+
+    def __init__(
+        self,
+        cache: Optional[ICache] = None,
+        *,
+        ttl_seconds: int = DEFAULT_TTL_SECONDS,
+        max_entries: int = DEFAULT_MAX_ENTRIES,
+        sweep_seconds: int = DEFAULT_SWEEP_SECONDS,
+        namespace: str = DEFAULT_NAMESPACE,
+    ) -> None:
+        self._cache = cache
+        self._ttl = ttl_seconds
+        self._max = max_entries
+        self._sweep = sweep_seconds
+        self._ns = namespace
+
+        self._memory: "OrderedDict[str, float]" = OrderedDict()
+        self._lock = threading.Lock()
+        self._last_sweep = time.time()
+
+    # ---- sync API ------------------------------------------------------------
+    def has_sync(self, id_: str) -> bool:
+        with self._lock:
+            self._maybe_sweep_locked()
+            exp = self._memory.get(id_)
+            if exp is not None:
+                if exp > time.time():
+                    self._memory.move_to_end(id_)
+                    return True
+                self._memory.pop(id_, None)
+        # Memory miss: check the external cache.
+        if self._cache is not None:
+            hit = self._cache_get(self._key(id_))
+            if hit:
+                # Back-fill memory.
+                with self._lock:
+                    self._memory[id_] = time.time() + self._ttl
+                    self._memory.move_to_end(id_)
+                    self._evict_locked()
+                return True
+        return False
+
+    def add_sync(self, id_: str) -> None:
+        expire_at = time.time() + self._ttl
+        with self._lock:
+            self._memory[id_] = expire_at
+            self._memory.move_to_end(id_)
+            self._evict_locked()
+        if self._cache is not None:
+            try:
+                self._cache.set(self._key(id_), "1", int(expire_at))
+            except Exception as e:  # pragma: no cover - defensive
+                logger.debug("seen_cache: ICache.set failed: %s", e)
+
+    # ---- async wrappers (identical semantics) --------------------------------
+    async def has(self, id_: str) -> bool:
+        return self.has_sync(id_)
+
+    async def add(self, id_: str) -> None:
+        self.add_sync(id_)
+
+    # ---- internals -----------------------------------------------------------
+    def _key(self, id_: str) -> str:
+        return f"{self._ns}{id_}"
+
+    def _cache_get(self, key: str) -> Optional[str]:
+        try:
+            return self._cache.get(key)  # type: ignore[union-attr]
+        except Exception as e:
+            logger.debug("seen_cache: ICache.get failed: %s", e)
+            return None
+
+    def _evict_locked(self) -> None:
+        while len(self._memory) > self._max:
+            self._memory.popitem(last=False)
+
+    def _maybe_sweep_locked(self) -> None:
+        now = time.time()
+        if now - self._last_sweep < self._sweep:
+            return
+        self._last_sweep = now
+        expired = [k for k, exp in self._memory.items() if exp <= now]
+        for k in expired:
+            self._memory.pop(k, None)
+
+    def size(self) -> int:
+        with self._lock:
+            return len(self._memory)
diff --git a/lark_channel/channel/safety/media_pipeline.py b/lark_channel/channel/safety/media_pipeline.py
new file mode 100644
index 0000000..4b82eec
--- /dev/null
+++ b/lark_channel/channel/safety/media_pipeline.py
@@ -0,0 +1,146 @@
+"""Media batching: debounce + bundle consecutive compatible media messages.
+
+Parallel to ``ChatPipelineManager`` but with simpler semantics:
+
+- Key: ``(chat_id, kind, reply_to, thread_id)``.
+- Compatible run: same key, same kind, within ``delay_ms``.
+- Incompatible push (different kind, or text intervenes) flushes the
+  current batch first, then starts a new one with the new message.
+- ``max_items`` cap: flushes the current batch and starts fresh.
+
+Output is a single ``InboundMessage`` whose ``batched_sources`` carries the
+ordered list of source messages. The merged message is the last source
+(latest metadata: id, create_time, mentions); ``content`` and ``resources``
+are unchanged from the last source - consumers should iterate
+``batched_sources`` to access all media.
+"""
+
+import asyncio
+from dataclasses import dataclass, field
+from typing import Any, Awaitable, Callable, Dict, List, Optional, Tuple
+
+from lark_channel.core.log import logger
+
+from ..types import InboundMessage
+from .types import MediaBatchConfig
+
+MediaFlushHandler = Callable[[InboundMessage], Awaitable[None]]
+
+
+def _kind_of(msg: InboundMessage) -> str:
+    """Identify the media kind for batching. Empty string means non-media."""
+    return msg.raw_content_type or ""
+
+
+def _key_of(msg: InboundMessage) -> Tuple[str, str, str, str]:
+    chat_id = msg.conversation.chat_id or ""
+    kind = _kind_of(msg)
+    reply_to = msg.reply.message_id if msg.reply else ""
+    thread_id = getattr(msg.conversation, "thread_id", "") or ""
+    return (chat_id, kind, reply_to, thread_id)
+
+
+def _attach_sources_to_last(sources: List[InboundMessage]) -> InboundMessage:
+    """Attach a media batch to the last source message and return that carrier.
+
+    Use the last message as the carrier (latest metadata), attach all
+    sources as ``batched_sources`` in arrival order.
+    """
+    if len(sources) == 1:
+        return sources[0]
+    last = sources[-1]
+    last.batched_sources = list(sources)
+    return last
+
+
+@dataclass
+class _Bucket:
+    sources: List[InboundMessage] = field(default_factory=list)
+    timer: Optional[asyncio.TimerHandle] = None
+
+
+class MediaPipelineManager:
+    """Per-key debounce + flush. Compatible with ``ChatPipelineManager``'s
+    lifecycle: ``push(msg, handler)`` schedules; ``dispose()`` drains.
+    """
+
+    def __init__(
+        self,
+        config: MediaBatchConfig,
+        loop: asyncio.AbstractEventLoop,
+    ) -> None:
+        self._config = config
+        self._loop = loop
+        self._buckets: Dict[Tuple[str, str, str, str], _Bucket] = {}
+        self._handler: Optional[MediaFlushHandler] = None
+
+    @property
+    def enabled(self) -> bool:
+        return self._config.enabled
+
+    def is_compatible(self, msg: InboundMessage) -> bool:
+        kind = _kind_of(msg)
+        return self._config.enabled and kind in self._config.compatible_kinds
+
+    async def push(self, msg: InboundMessage, handler: MediaFlushHandler) -> None:
+        """Add ``msg`` to its bucket. Flushes the bucket if max_items reached."""
+        self._handler = handler
+        key = _key_of(msg)
+        bucket = self._buckets.setdefault(key, _Bucket())
+        bucket.sources.append(msg)
+
+        if len(bucket.sources) >= self._config.max_items:
+            self._cancel_timer(bucket)
+            await self._flush_bucket(key)
+            return
+
+        self._cancel_timer(bucket)
+        bucket.timer = self._loop.call_later(
+            self._config.delay_ms / 1000.0,
+            lambda: self._spawn_flush(key),
+        )
+
+    def _spawn_flush(self, key: Tuple[str, str, str, str]) -> None:
+        """Schedule ``_flush_bucket(key)`` with a logging done-callback so
+        timer-driven flush failures do not vanish into a fire-and-forget task.
+        """
+        task = self._loop.create_task(self._flush_bucket(key))
+
+        def _on_done(t: "asyncio.Task[Any]") -> None:
+            if t.cancelled():
+                return
+            exc = t.exception()
+            if exc is not None:
+                logger.warning("media_pipeline: bucket flush failed: %s", exc)
+
+        task.add_done_callback(_on_done)
+
+    async def flush_incompatible_for(self, msg: InboundMessage) -> None:
+        """Called when a non-compatible message arrives in a chat that has a
+        pending bucket - flushes any bucket sharing the chat_id."""
+        chat_id = msg.conversation.chat_id or ""
+        keys_to_flush = [k for k in list(self._buckets.keys()) if k[0] == chat_id]
+        for k in keys_to_flush:
+            await self._flush_bucket(k)
+
+    async def _flush_bucket(self, key: Tuple[str, str, str, str]) -> None:
+        bucket = self._buckets.pop(key, None)
+        if bucket is None or not bucket.sources:
+            return
+        self._cancel_timer(bucket)
+        merged = _attach_sources_to_last(bucket.sources)
+        if self._handler is not None:
+            await self._handler(merged)
+
+    def _cancel_timer(self, bucket: _Bucket) -> None:
+        if bucket.timer is not None:
+            try:
+                bucket.timer.cancel()
+            except Exception:
+                pass
+            bucket.timer = None
+
+    async def dispose(self) -> None:
+        """Flush any remaining buckets - call during channel shutdown."""
+        for key in list(self._buckets.keys()):
+            await self._flush_bucket(key)
diff --git a/lark_channel/channel/safety/pipeline.py b/lark_channel/channel/safety/pipeline.py
new file mode 100644
index 0000000..d1909b1
--- /dev/null
+++ b/lark_channel/channel/safety/pipeline.py
@@ -0,0 +1,293 @@
+"""SafetyPipeline — three-tier entry point for events.
+
+Exposes three push methods, each enforcing a different subset of the full
+pipeline:
+
+    push_message — full pipeline (stale / dedup / policy / lock / batch / queue)
+    push_action  — dedup + lock + queue (cardAction / comment)
+    push_light   — dedup only (reaction)
+
+The pipeline owns a `PolicyGate`, `SeenCache`, `ProcessingLock`, and
+`ChatPipelineManager`, composing them into a single call site.
+"""
+
+import asyncio
+import inspect
+from typing import Awaitable, Callable, Optional
+
+from lark_channel.core.cache import ICache
+from lark_channel.core.log import logger
+
+from ..config import PolicyConfig
+from ..types import InboundMessage
+from .chat_pipeline import ChatPipelineManager
+from .media_pipeline import MediaPipelineManager
+from .policy_gate import PolicyGate
+from .processing_lock import ProcessingLock
+from .dedup_cache import SeenCache
+from .stale_detector import DEFAULT_STALE_MS, is_stale
+from .types import (
+    ChatQueueConfig,
+    DedupConfig,
+    MediaBatchConfig,
+    RejectEvent,
+    RejectReason,
+    TextBatchConfig,
+)
+
+MessageDispatch = Callable[[InboundMessage], Awaitable[None]]
+OnReject = Callable[[RejectEvent], None]
+
+
+class SafetyPipeline:
+    """Facade that wires stale / dedup / policy / lock / batch / queue."""
+
+    def __init__(
+        self,
+        *,
+        loop: asyncio.AbstractEventLoop,
+        on_message: MessageDispatch,
+        on_reject: Optional[OnReject] = None,
+        policy: Optional[PolicyConfig] = None,
+        cache: Optional[ICache] = None,
+        dedup_config: Optional[DedupConfig] = None,
+        batch_config: Optional[TextBatchConfig] = None,
+        media_batch_config: Optional[MediaBatchConfig] = None,
+        queue_config: Optional[ChatQueueConfig] = None,
+        stale_window_ms: int = DEFAULT_STALE_MS,
+        processing_lock_ttl_ms: int = 5 * 60 * 1000,
+        drop_self_sent: bool = True,
+    ) -> None:
+        self._loop = loop
+        self._on_message = on_message
+        self._on_reject = on_reject
+        self._stale_window_ms = stale_window_ms
+        self._drop_self_sent = drop_self_sent
+        self._bot_open_id: Optional[str] = None
+
+        dedup_config = dedup_config or DedupConfig()
+        self._seen = SeenCache(
+            cache=cache,
+            ttl_seconds=dedup_config.ttl_seconds,
+            max_entries=dedup_config.max_entries,
+            sweep_seconds=dedup_config.sweep_seconds,
+        )
+        self._lock = ProcessingLock(ttl_ms=processing_lock_ttl_ms)
+        self._policy = PolicyGate(policy or PolicyConfig())
+        self._manager = ChatPipelineManager(
+            config=batch_config or TextBatchConfig(),
+            loop=loop,
+            queue_config=queue_config or ChatQueueConfig(),
+        )
+        self._media = MediaPipelineManager(
+            config=media_batch_config or MediaBatchConfig(),
+            loop=loop,
+        )
+
+    # ---- public accessors ----------------------------------------------------
+    @property
+    def seen(self) -> SeenCache:
+        return self._seen
+
+    def set_bot_open_id(self, open_id: Optional[str]) -> None:
+        self._bot_open_id = open_id
+        self._policy.set_bot_open_id(open_id)
+
+    def update_policy(self, **changes) -> None:
+        self._policy.update_policy(**changes)
+
+    def get_policy(self) -> PolicyConfig:
+        return self._policy.get_policy()
+
+    def block_batch_scope(self, scope: str) -> None:
+        self._manager.block_scope(scope)
+
+    def unblock_batch_scope(self, scope: str) -> None:
+        self._manager.unblock_scope(scope)
+
+    def cancel_batch_scope(self, scope: str) -> None:
+        self._manager.cancel_scope(scope)
+
+    def _emit_reject(self, msg: InboundMessage, reason: "RejectReason") -> None:
+        """Emit a :class:`RejectEvent` to the caller-supplied hook, if any.
+
+        Kept internal because the event taxonomy is deliberately narrow; only
+        :meth:`push_message` calls this. Swallows handler exceptions so a
+        buggy reject callback can't break message processing.
+        """
+        if self._on_reject is None:
+            return
+        try:
+            self._on_reject(RejectEvent(
+                message_id=msg.id,
+                chat_id=msg.conversation.chat_id,
+                sender_id=msg.sender.open_id,
+                reason=reason,
+            ))
+        except Exception as e:  # pragma: no cover
+            logger.warning("safety: on_reject handler raised: %s", e)
+
+    # ---- tier 1: full message pipeline ---------------------------------------
+    async def push_message(self, msg: InboundMessage) -> None:
+        """Run a message through the complete safety gauntlet."""
+        # 1. Stale detector — emits RejectEvent(reason="stale") so subscribers
+        #    can observe the drop.
+        if is_stale(msg.create_time * 1000 if msg.create_time < 10**12 else msg.create_time,
+                    self._stale_window_ms):
+            logger.debug("safety: stale drop message_id=%s", msg.id)
+            self._emit_reject(msg, "stale")
+            return
+
+        # 2. Dedup (seen cache) — emits RejectEvent(reason="duplicate"); same
+        #    rationale as the stale branch above.
+        if await self._seen.has(msg.id):
+            logger.debug("safety: dedup drop message_id=%s", msg.id)
+            self._emit_reject(msg, "duplicate")
+            return
+
+        # 2.5 Self-sent filter — only when bot identity is known. Conservative:
+        #     unknown identity skips the filter so legitimate user messages
+        #     during startup aren't dropped.
+        if (
+            self._drop_self_sent
+            and self._bot_open_id is not None
+            and msg.sender.open_id == self._bot_open_id
+        ):
+            logger.debug("safety: self-sent drop message_id=%s", msg.id)
+            self._emit_reject(msg, "self_sent")
+            return
+
+        # 3. Policy gate
+        decision = self._policy.evaluate(msg)
+        if not decision.allowed:
+            if decision.reason is not None:
+                self._emit_reject(msg, decision.reason)
+            else:
+                logger.debug("safety: policy drop message_id=%s reason=None", msg.id)
+            return
+
+        # 4. Processing lock
+        if not self._lock.acquire(msg.id):
+            logger.debug("safety: lock contention drop message_id=%s", msg.id)
+            self._emit_reject(msg, "lock_contention")
+            return
+
+        # 5. Media batching takes precedence over the chat batch/queue path
+        #    when the message is a compatible media kind. The chat queue is
+        #    bypassed for batched media — the merged dispatch goes directly
+        #    to the handler. Text and other kinds fall through to the
+        #    existing batch+queue flow, but first we flush any pending media
+        #    bucket on the same chat so order is preserved.
+        if self._media.is_compatible(msg):
+            await self._media.push(msg, self._media_flush_handler)
+            return
+
+        # Non-media (or non-compatible kind): flush any pending media bucket
+        # in this chat first so order is preserved across the kind switch.
+        if self._media.enabled:
+            await self._media.flush_incompatible_for(msg)
+
+        # 5a. batch + serialize (or direct if queue disabled)
+        if self._manager.queue_enabled:
+            self._manager.push(
+                msg.conversation.chat_id or msg.id,
+                msg,
+                self._message_flush_handler,
+            )
+        else:
+            await self._message_flush_handler(msg, [msg])
+
+    async def _media_flush_handler(self, merged: InboundMessage) -> None:
+        try:
+            await _maybe_await(self._on_message(merged))
+        except asyncio.CancelledError:
+            raise
+        except Exception as e:
+            logger.exception("safety: on_message handler raised: %s", e)
+        finally:
+            sources = merged.batched_sources or [merged]
+            for m in sources:
+                try:
+                    await self._seen.add(m.id)
+                except Exception:  # pragma: no cover
+                    pass
+                self._lock.release(m.id)
+
+    async def _message_flush_handler(
+        self, merged: InboundMessage, sources: "list[InboundMessage]"
+    ) -> None:
+        try:
+            await _maybe_await(self._on_message(merged))
+        except asyncio.CancelledError:
+            raise
+        except Exception as e:
+            logger.exception("safety: on_message handler raised: %s", e)
+        finally:
+            # Mark each source message as seen + release locks
+            for m in sources:
+                try:
+                    await self._seen.add(m.id)
+                except Exception:  # pragma: no cover
+                    pass
+                self._lock.release(m.id)
+
+    # ---- tier 2: cardAction / comment (dedup + lock + serial) ----------------
+    async def push_action(
+        self,
+        event_id: str,
+        queue_scope: str,
+        handler: Callable[[], Awaitable[None]],
+    ) -> None:
+        if await self._seen.has(event_id):
+            logger.debug("safety: dedup drop action event_id=%s", event_id)
+            return
+        if not self._lock.acquire(event_id):
+            logger.debug("safety: lock contention drop action event_id=%s", event_id)
+            return
+
+        async def runner() -> None:
+            try:
+                await _maybe_await(handler())
+            except asyncio.CancelledError:
+                raise
+            except Exception as e:
+                logger.exception("safety: action handler raised: %s", e)
+            finally:
+                try:
+                    await self._seen.add(event_id)
+                except Exception:  # pragma: no cover
+                    pass
+                self._lock.release(event_id)
+
+        self._manager.run(queue_scope, runner)
+
+    # ---- tier 3: reaction (dedup only) ---------------------------------------
+    async def push_light(
+        self,
+        event_id: str,
+        handler: Callable[[], Awaitable[None]],
+    ) -> None:
+        if await self._seen.has(event_id):
+            logger.debug("safety: dedup drop light event_id=%s", event_id)
+            return
+        try:
+            await _maybe_await(handler())
+        except asyncio.CancelledError:
+            raise
+        except Exception as e:
+            logger.exception("safety: light handler raised: %s", e)
+        finally:
+            try:
+                await self._seen.add(event_id)
+            except Exception:  # pragma: no cover
+                pass
+
+    async def dispose(self) -> None:
+        await self._manager.dispose()
+        await self._media.dispose()
+
+
+async def _maybe_await(v):
+    if inspect.isawaitable(v):
+        return await v
+    return v
diff --git a/lark_channel/channel/safety/policy_gate.py b/lark_channel/channel/safety/policy_gate.py
new file mode 100644
index 0000000..8245667
--- /dev/null
+++ b/lark_channel/channel/safety/policy_gate.py
@@ -0,0 +1,169 @@
+"""Declarative policy judgement with run-time updatability.
+
+Decision order:
+
+Group chat:
+    1. ``group_policy`` / per-chat override gates the chat or sender.
+    2. ``require_mention`` checks bot mention or optionally ``@all``.
+    3. ``respond_to_mention_all=False`` blocks standalone ``@all`` mentions.
+
+DM:
+    - ``dm_policy``: open / allowlist / blocklist / disabled
+    - ``allow_from`` / ``deny_from`` match configured sender identity fields
+
+Returns `(allowed: bool, reason?: RejectReason)`.
+"""
+
+import threading
+from dataclasses import dataclass
+from typing import List, Optional, Set
+
+from ..config import PolicyConfig
+from ..types import Identity, InboundMessage
+from .types import RejectReason
+
+
+_VALID_SENDER_IDENTITY_FIELDS = {"open_id", "user_id", "union_id"}
+
+
+def _sender_identity_values(sender: Identity, fields: List[str]) -> Set[str]:
+    values: Set[str] = set()
+    for field in fields or ["open_id"]:
+        if field not in _VALID_SENDER_IDENTITY_FIELDS:
+            raise ValueError(f"invalid sender identity field: {field}")
+        value = str(getattr(sender, field, "") or "")
+        if value:
+            values.add(value)
+    return values
+
+
+def _matches_any_sender_identity(sender_ids: Set[str], candidates) -> bool:
+    return bool(sender_ids and candidates and sender_ids.intersection(set(candidates)))
+
+
+@dataclass
+class PolicyDecision:
+    allowed: bool
+    reason: Optional[RejectReason] = None
+
+
+class PolicyGate:
+    def __init__(self, policy: Optional[PolicyConfig] = None) -> None:
+        self._policy = policy or PolicyConfig()
+        self._bot_open_id: Optional[str] = None
+        self._lock = threading.Lock()
+
+    def set_bot_open_id(self, open_id: Optional[str]) -> None:
+        with self._lock:
+            self._bot_open_id = open_id
+
+    def get_policy(self) -> PolicyConfig:
+        with self._lock:
+            return self._policy
+
+    def update_policy(self, **changes) -> None:
+        """Run-time partial update. Unknown keys are ignored."""
+        with self._lock:
+            for k, v in changes.items():
+                if hasattr(self._policy, k):
+                    setattr(self._policy, k, v)
+
+    def evaluate(self, msg: InboundMessage) -> PolicyDecision:
+        with self._lock:
+            policy = self._policy
+            bot_open_id = self._bot_open_id
+
+        sender_ids = _sender_identity_values(msg.sender, policy.sender_identity_fields)
+
+        # 1. admin bypass — always allowed regardless of any other gate
+        if policy.admins and _matches_any_sender_identity(sender_ids, policy.admins):
+            return PolicyDecision(True)
+
+        chat_type = msg.conversation.chat_type
+        if chat_type in ("group", "topic"):
+            return self._evaluate_group(msg, policy, bot_open_id, sender_ids)
+        return self._evaluate_dm(msg, policy, sender_ids)
+
+    def _evaluate_group(
+        self,
+        msg: InboundMessage,
+        policy: PolicyConfig,
+        bot_open_id: Optional[str],
+        sender_ids: Set[str],
+    ) -> PolicyDecision:
+        override = (policy.group_overrides or {}).get(msg.conversation.chat_id)
+
+        # explicit per-override disable
+        if override and override.enabled is False:
+            return PolicyDecision(False, "policy_group_disabled")
+
+        policy_kind = override.policy if override and override.policy else policy.group_policy
+
+        if policy_kind == "disabled":
+            return PolicyDecision(False, "policy_group_disabled")
+
+        if policy_kind == "blocklist":
+            # Per-override blocklist gates the chat's sender identities.
+            # Global group_blocklist gates chat_ids.
+            if override and override.blocklist is not None:
+                if _matches_any_sender_identity(sender_ids, override.blocklist):
+                    return PolicyDecision(False, "policy_blocklist")
+            elif policy.group_blocklist and msg.conversation.chat_id in policy.group_blocklist:
+                return PolicyDecision(False, "policy_blocklist")
+            # Otherwise fall through — blocklist mode permits everyone not listed.
+
+        elif policy_kind == "admin_only":
+            if not policy.admins or not _matches_any_sender_identity(sender_ids, policy.admins):
+                return PolicyDecision(False, "policy_admin_only")
+            # Admins fall through to require_mention; an admin who forgot to
+            # @-mention the bot in a group still hits the mention gate.
+
+        elif policy_kind == "allowlist":
+            # Per-override allowlist gates the chat's sender identities.
+            # Global group_allowlist gates chat_ids.
+            if override and override.allowlist is not None:
+                if not _matches_any_sender_identity(sender_ids, override.allowlist):
+                    return PolicyDecision(False, "policy_group_not_in_allowlist")
+            else:
+                if not policy.group_allowlist or msg.conversation.chat_id not in policy.group_allowlist:
+                    return PolicyDecision(False, "policy_group_not_in_allowlist")
+
+        # require_mention / mention_all (unchanged)
+        require_mention = (
+            override.require_mention
+            if override and override.require_mention is not None
+            else policy.require_mention
+        )
+        respond_mention_all = (
+            override.respond_to_mention_all
+            if override and override.respond_to_mention_all is not None
+            else policy.respond_to_mention_all
+        )
+        mentioned_bot = bool(
+            bot_open_id and any(m.open_id == bot_open_id for m in msg.mentions)
+        )
+        if require_mention:
+            if not mentioned_bot and not (respond_mention_all and msg.mentioned_all):
+                return PolicyDecision(False, "policy_no_mention")
+
+        if msg.mentioned_all and not respond_mention_all and not mentioned_bot:
+            return PolicyDecision(False, "policy_mention_all_blocked")
+
+        if policy.allow_from and not _matches_any_sender_identity(sender_ids, policy.allow_from):
+            return PolicyDecision(False, "policy_sender_not_allowed")
+
+        return PolicyDecision(True)
+
+    def _evaluate_dm(
+        self, msg: InboundMessage, policy: PolicyConfig, sender_ids: Set[str]
+    ) -> PolicyDecision:
+        if policy.dm_policy == "disabled":
+            return PolicyDecision(False, "policy_dm_disabled")
+        if policy.dm_policy == "blocklist":
+            if policy.deny_from and _matches_any_sender_identity(sender_ids, policy.deny_from):
+                return PolicyDecision(False, "policy_blocklist")
+            return PolicyDecision(True)
+        if policy.dm_policy == "allowlist":
+            if not policy.allow_from or not _matches_any_sender_identity(sender_ids, policy.allow_from):
+                return PolicyDecision(False, "policy_dm_not_in_allowlist")
+        return PolicyDecision(True)
diff --git a/lark_channel/channel/safety/processing_lock.py b/lark_channel/channel/safety/processing_lock.py
new file mode 100644
index 0000000..0c2669a
--- /dev/null
+++ b/lark_channel/channel/safety/processing_lock.py
@@ -0,0 +1,81 @@
+"""Short-TTL in-memory lock that complements `SeenCache`.
+
+The two pieces of dedup state serve different purposes:
+
+- `SeenCache` = "this id finished processing at some point" — long TTL (12h),
+  survives across reconnects, optionally shared via Redis.
+- `ProcessingLock` = "this id is being processed RIGHT NOW by this worker" —
+  short TTL (5min), memory-only. Needed because `SeenCache.add()` only happens
+  AFTER the handler returns, so during a long-running handler a WS reconnect could
+  re-deliver the same event and we'd process it twice.
+
+`acquire(id)` returns False when another coroutine still holds the lock.
+"""
+
+import threading
+import time
+
+DEFAULT_TTL_MS = 5 * 60 * 1000
+# How often to walk the internal dict purging expired entries. Cheap in
+# absolute terms (a single pass over a dict that is bounded in practice by
+# in-flight request concurrency), but bounded so we never do it more than
+# once per minute even under heavy traffic.
+DEFAULT_SWEEP_INTERVAL_MS = 60 * 1000
+
+
+class ProcessingLock:
+    def __init__(
+        self,
+        ttl_ms: int = DEFAULT_TTL_MS,
+        *,
+        sweep_interval_ms: int = DEFAULT_SWEEP_INTERVAL_MS,
+    ) -> None:
+        self._ttl_ms = ttl_ms
+        self._sweep_interval_ms = sweep_interval_ms
+        self._locks: "dict[str, float]" = {}
+        self._mu = threading.Lock()
+        # Start "due for sweep right now" so the first `acquire` call also
+        # clears anything left over from a prior instance that shared the
+        # dict (there isn't one today, but belt-and-suspenders).
+        self._last_sweep_ms = 0
+
+    @staticmethod
+    def _now_ms() -> int:
+        # Monotonic clock: immune to NTP steps and DST jumps. Wall-clock
+        # would let a clock-rewind silently extend held locks past the
+        # intended TTL (or expire them early).
+        return int(time.monotonic() * 1000)
+
+    def _maybe_sweep_locked(self, now_ms: int) -> None:
+        """Drop expired entries if we haven't swept recently. Call with
+        ``self._mu`` already held."""
+        if now_ms - self._last_sweep_ms < self._sweep_interval_ms:
+            return
+        expired = [k for k, exp in self._locks.items() if exp <= now_ms]
+        for k in expired:
+            self._locks.pop(k, None)
+        self._last_sweep_ms = now_ms
+
+    def acquire(self, id_: str) -> bool:
+        """Return True if lock was acquired, False if already held and fresh."""
+        now_ms = self._now_ms()
+        with self._mu:
+            self._maybe_sweep_locked(now_ms)
+            exp = self._locks.get(id_)
+            if exp is not None and exp > now_ms:
+                return False
+            self._locks[id_] = now_ms + self._ttl_ms
+            return True
+
+    def release(self, id_: str) -> None:
+        with self._mu:
+            self._locks.pop(id_, None)
+
+    def size(self) -> int:
+        now_ms = self._now_ms()
+        with self._mu:
+            expired = [k for k, exp in self._locks.items() if exp <= now_ms]
+            for k in expired:
+                self._locks.pop(k, None)
+            self._last_sweep_ms = now_ms
+            return len(self._locks)
diff --git a/lark_channel/channel/safety/stale_detector.py b/lark_channel/channel/safety/stale_detector.py
new file mode 100644
index 0000000..2ab0c59
--- /dev/null
+++ b/lark_channel/channel/safety/stale_detector.py
@@ -0,0 +1,19 @@
+"""Drop messages that are too old to care about.
+
+Motivation: after a WebSocket reconnect, Feishu replays recent events it
+believes we missed. If our process just restarted, that means we'll receive
+messages from before the crash — which the user already stopped expecting a
+reply to. We silently drop events older than `window_ms` (default 30 min).
+"""
+
+import time
+
+DEFAULT_STALE_MS = 30 * 60 * 1000
+
+
+def is_stale(create_time_ms: int, window_ms: int = DEFAULT_STALE_MS) -> bool:
+    """Return True if `create_time_ms` is older than `window_ms` ago."""
+    if not create_time_ms:
+        return False
+    now_ms = int(time.time() * 1000)
+    return (now_ms - create_time_ms) > window_ms
diff --git a/lark_channel/channel/safety/types.py b/lark_channel/channel/safety/types.py
new file mode 100644
index 0000000..fae568c
--- /dev/null
+++ b/lark_channel/channel/safety/types.py
@@ -0,0 +1,101 @@
+"""Safety-layer primitive types.
+
+``DedupConfig``, ``TextBatchConfig``, and ``ChatQueueConfig`` used to live
+here but were promoted into :mod:`..config` so the public schema is
+self-contained and to break a circular import (safety eagerly imports
+``SafetyPipeline`` which needs :class:`PolicyConfig`). They are re-exported
+from this module as back-compat aliases.
+
+``MediaBatchConfig`` lives here and is consumed by
+:class:`MediaPipelineManager` (wired into :class:`SafetyPipeline` so
+compatible-kind media within ``delay_ms`` are merged into a single dispatch
+carrying ``InboundMessage.batched_sources``). Default is ``enabled=False``
+so existing deployments see no behaviour change. ``BatchConfig`` is kept as
+a legacy compound shape for back-compat and is not consumed by the pipeline.
+"""
+
+from dataclasses import dataclass, field
+from typing import Literal
+
+# Re-export from the public schema so existing `from .types import …` call
+# sites inside the safety package keep working.
+from ..config import ChatQueueConfig, DedupConfig, TextBatchConfig  # noqa: F401
+
+__all__ = [
+    "BatchConfig",
+    "ChatQueueConfig",
+    "DedupConfig",
+    "MediaBatchConfig",
+    "RejectEvent",
+    "RejectReason",
+    "TextBatchConfig",
+]
+
+# ---- Reject taxonomy --------------------------------------------------------
+
+RejectReason = Literal[
+    # Non-policy reasons
+    "stale",
+    "duplicate",
+    "lock_contention",
+    "self_sent",
+    # Policy reasons (unified policy_ prefix)
+    "policy_dm_disabled",
+    "policy_group_disabled",
+    "policy_dm_not_in_allowlist",
+    "policy_group_not_in_allowlist",
+    "policy_blocklist",
+    "policy_admin_only",
+    "policy_no_mention",
+    "policy_mention_all_blocked",
+    "policy_sender_not_allowed",
+]
+
+
+@dataclass
+class RejectEvent:
+    """Emitted by SafetyPipeline when a message is filtered out.
+
+    Carries just enough info for the caller to log or surface the decision.
+    Reasons include both policy decisions and runtime safety gates such as
+    stale messages, duplicate delivery, lock contention, and self-sent drops.
+    """
+
+    message_id: str
+    chat_id: str
+    sender_id: str
+    reason: RejectReason
+
+
+# ---- Batch config ----------------------------------------------------------
+
+
+@dataclass
+class MediaBatchConfig:
+    """Debounce + bundle successive media messages in the same chat.
+
+    A run of compatible media messages (same kind, same chat, no intervening
+    text) within ``delay_ms`` is collapsed into a single dispatch carrying
+    :attr:`InboundMessage.batched_sources` — the list of source messages in
+    arrival order.
+
+    Default: ``enabled=False`` so existing deployments see no behavior change.
+    Opt in by setting ``enabled=True``.
+    """
+
+    enabled: bool = False
+    delay_ms: int = 800
+    max_items: int = 9
+    compatible_kinds: frozenset = field(
+        default_factory=lambda: frozenset({"image", "file", "audio", "video"})
+    )
+
+
+@dataclass
+class BatchConfig:
+    """Reserved: text + media batch settings as a pair (legacy shape, kept
+    for back-compat — new code should use TextBatchConfig + MediaBatchConfig
+    directly via SafetyConfig)."""
+
+    text: TextBatchConfig = field(default_factory=TextBatchConfig)
+    media: MediaBatchConfig = field(default_factory=MediaBatchConfig)
diff --git a/lark_channel/channel/tests/__init__.py b/lark_channel/channel/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/lark_channel/channel/tests/conftest.py b/lark_channel/channel/tests/conftest.py
new file mode 100644
index 0000000..b1685be
--- /dev/null
+++ b/lark_channel/channel/tests/conftest.py
@@ -0,0 +1 @@
+"""Shared pytest fixtures for the channel test suite."""
diff --git a/lark_channel/channel/tests/snapshots/markdown_structured.json b/lark_channel/channel/tests/snapshots/markdown_structured.json
new file mode 100644
index 0000000..5b1def4
--- /dev/null
+++ b/lark_channel/channel/tests/snapshots/markdown_structured.json
@@ -0,0 +1,362 @@
+{
+  "01_plain": {
+    "zh_cn": {
+      "content": [
+        [
+          {
+            "tag": "text",
+            "text": "这是普通文本，没有任何 markdown。"
+          }
+        ]
+      ],
+      "title": ""
+    }
+  },
+  "02_bold": {
+    "zh_cn": {
+      "content": [
+        [
+          {
+            "tag": "text",
+            "text": "下面是 "
+          },
+          {
+            "style": [
+              "bold"
+            ],
+            "tag": "text",
+            "text": "粗体"
+          },
+          {
+            "tag": "text",
+            "text": " 文字。"
+          }
+        ]
+      ],
+      "title": ""
+    }
+  },
+  "03_italic": {
+    "zh_cn": {
+      "content": [
+        [
+          {
+            "tag": "text",
+            "text": "下面是 "
+          },
+          {
+            "style": [
+              "italic"
+            ],
+            "tag": "text",
+            "text": "斜体"
+          },
+          {
+            "tag": "text",
+            "text": " 文字。"
+          }
+        ]
+      ],
+      "title": ""
+    }
+  },
+  "04_bold_italic": {
+    "zh_cn": {
+      "content": [
+        [
+          {
+            "tag": "text",
+            "text": "组合 "
+          },
+          {
+            "style": [
+              "bold"
+            ],
+            "tag": "text",
+            "text": "*粗+斜"
+          },
+          {
+            "tag": "text",
+            "text": "* 看一下。"
+          }
+        ]
+      ],
+      "title": ""
+    }
+  },
+  "05_h1": {
+    "zh_cn": {
+      "content": [
+        [
+          {
+            "style": [
+              "bold"
+            ],
+            "tag": "text",
+            "text": "H1 标题（应该字号最大）"
+          }
+        ]
+      ],
+      "title": ""
+    }
+  },
+  "06_h2": {
+    "zh_cn": {
+      "content": [
+        [
+          {
+            "style": [
+              "bold"
+            ],
+            "tag": "text",
+            "text": "H2 标题（中号）"
+          }
+        ]
+      ],
+      "title": ""
+    }
+  },
+  "07_h3": {
+    "zh_cn": {
+      "content": [
+        [
+          {
+            "style": [
+              "bold"
+            ],
+            "tag": "text",
+            "text": "H3 标题（小号）"
+          }
+        ]
+      ],
+      "title": ""
+    }
+  },
+  "08_quote": {
+    "zh_cn": {
+      "content": [
+        [
+          {
+            "tag": "text",
+            "text": "│ "
+          },
+          {
+            "tag": "text",
+            "text": "这是引用块第一行\n引用块第二行"
+          }
+        ]
+      ],
+      "title": ""
+    }
+  },
+  "09_nested_quote": {
+    "zh_cn": {
+      "content": [
+        [
+          {
+            "tag": "text",
+            "text": "│ "
+          },
+          {
+            "tag": "text",
+            "text": "外层引用\n> 嵌套引用"
+          }
+        ]
+      ],
+      "title": ""
+    }
+  },
+  "10_ul": {
+    "zh_cn": {
+      "content": [
+        [
+          {
+            "tag": "text",
+            "text": "• 苹果"
+          }
+        ],
+        [
+          {
+            "tag": "text",
+            "text": "• 香蕉"
+          }
+        ],
+        [
+          {
+            "tag": "text",
+            "text": "• 樱桃"
+          }
+        ]
+      ],
+      "title": ""
+    }
+  },
+  "11_ol": {
+    "zh_cn": {
+      "content": [
+        [
+          {
+            "tag": "text",
+            "text": "1. 第一"
+          }
+        ],
+        [
+          {
+            "tag": "text",
+            "text": "2. 第二"
+          }
+        ],
+        [
+          {
+            "tag": "text",
+            "text": "3. 第三"
+          }
+        ]
+      ],
+      "title": ""
+    }
+  },
+  "12_nested_ul": {
+    "zh_cn": {
+      "content": [
+        [
+          {
+            "tag": "text",
+            "text": "• 顶层"
+          }
+        ],
+        [
+          {
+            "tag": "text",
+            "text": "• 子项 1"
+          }
+        ],
+        [
+          {
+            "tag": "text",
+            "text": "• 子项 2"
+          }
+        ]
+      ],
+      "title": ""
+    }
+  },
+  "13_inline_code": {
+    "zh_cn": {
+      "content": [
+        [
+          {
+            "tag": "text",
+            "text": "命令是 "
+          },
+          {
+            "style": [
+              "code"
+            ],
+            "tag": "text",
+            "text": "git status"
+          },
+          {
+            "tag": "text",
+            "text": " 用来查看状态。"
+          }
+        ]
+      ],
+      "title": ""
+    }
+  },
+  "14_link": {
+    "zh_cn": {
+      "content": [
+        [
+          {
+            "tag": "text",
+            "text": "查看 "
+          },
+          {
+            "href": "https://example.com",
+            "tag": "a",
+            "text": "文档"
+          },
+          {
+            "tag": "text",
+            "text": " 了解更多。"
+          }
+        ]
+      ],
+      "title": ""
+    }
+  },
+  "15_code_fence": {
+    "zh_cn": {
+      "content": [
+        [
+          {
+            "language": "PYTHON",
+            "tag": "code_block",
+            "text": "print('hi')"
+          }
+        ]
+      ],
+      "title": ""
+    }
+  },
+  "16_composite": {
+    "zh_cn": {
+      "content": [
+        [
+          {
+            "style": [
+              "bold"
+            ],
+            "tag": "text",
+            "text": "标题"
+          }
+        ],
+        [
+          {
+            "style": [
+              "bold"
+            ],
+            "tag": "text",
+            "text": "重点"
+          },
+          {
+            "tag": "text",
+            "text": "：下面是清单。"
+          }
+        ],
+        [
+          {
+            "tag": "text",
+            "text": "• a"
+          }
+        ],
+        [
+          {
+            "tag": "text",
+            "text": "• b"
+          }
+        ],
+        [
+          {
+            "tag": "text",
+            "text": "│ "
+          },
+          {
+            "tag": "text",
+            "text": "引用"
+          }
+        ],
+        [
+          {
+            "language": "PYTHON",
+            "tag": "code_block",
+            "text": "print('done')"
+          }
+        ]
+      ],
+      "title": ""
+    }
+  }
+}
diff --git a/lark_channel/channel/tests/test_additional_message_converters.py b/lark_channel/channel/tests/test_additional_message_converters.py
new file mode 100644
index 0000000..b215e29
--- /dev/null
+++ b/lark_channel/channel/tests/test_additional_message_converters.py
@@ -0,0 +1,56 @@
+"""Parser tests for additional msg_type converters."""
+
+import json
+
+from lark_channel.channel.normalize.registry import parse_message_content
+from lark_channel.channel.types import (
+    FolderContent,
+    GeneralCalendarContent,
+    HongbaoContent,
+    MediaContent,
+    ShareCalendarEventContent,
+)
+
+
+def _c(d):
+    return json.dumps(d, ensure_ascii=False)
+
+
+def test_folder_parsed():
+    c = parse_message_content("folder", _c({"file_name": "archive", "file_size": 1024}))
+    assert isinstance(c, FolderContent)
+    assert c.file_name == "archive"
+    assert c.file_size == 1024
+
+
+def test_hongbao_parsed():
+    c = parse_message_content("hongbao", _c({"text": "恭喜发财", "amount": "888"}))
+    assert isinstance(c, HongbaoContent)
+    assert c.text == "恭喜发财"
+    assert c.amount == 888
+
+
+def test_general_calendar_parsed():
+    c = parse_message_content(
+        "general_calendar",
+        _c({"summary": "Q3 Review", "start_time": 1700000000, "end_time": 1700003600}),
+    )
+    assert isinstance(c, GeneralCalendarContent)
+    assert c.summary == "Q3 Review"
+    assert c.start_time == 1700000000
+
+
+def test_share_calendar_event_parsed():
+    c = parse_message_content(
+        "share_calendar_event",
+        _c({"summary": "Demo", "organizer_display_name": "Alice"}),
+    )
+    assert isinstance(c, ShareCalendarEventContent)
+    assert c.summary == "Demo"
+    assert c.organizer == "Alice"
+
+
+def test_video_aliased_to_media():
+    c = parse_message_content("video", _c({"file_key": "v_x", "duration": 5000}))
+    assert isinstance(c, MediaContent)
+    assert c.file_key == "v_x"
diff --git a/lark_channel/channel/tests/test_bot_identity.py b/lark_channel/channel/tests/test_bot_identity.py
new file mode 100644
index 0000000..2e18c8a
--- /dev/null
+++ b/lark_channel/channel/tests/test_bot_identity.py
@@ -0,0 +1,152 @@
+"""Bot identity fetch — unit tests with mocked Transport."""
+
+import json
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from lark_channel.channel.bot_identity import BotIdentity, fetch_bot_identity
+from lark_channel.core.model import Config, RawResponse
+
+
+def _raw(body: dict, status: int = 200) -> RawResponse:
+    r = RawResponse()
+    r.status_code = status
+    r.content = json.dumps(body).encode("utf-8")
+    return r
+
+
+def _fake_verify(cfg, request, option):
+    """Stub `core.token.auth.verify` so unit tests don't hit the real
+    tenant_access_token endpoint. The real function populates
+    ``option.tenant_access_token``; we just write a sentinel here.
+    """
+    option.tenant_access_token = "t-test"
+
+
+@pytest.mark.asyncio
+async def test_fetch_uses_bot_v3_info_first():
+    config = Config()
+    config.app_id = "cli_x"
+    config.app_secret = "sec"
+
+    bot_v3_resp = _raw({
+        "code": 0, "msg": "ok",
+        "data": {"bot": {"open_id": "ou_bot_1", "user_id": "u1",
+                         "app_name": "Demo Bot", "app_id": "cli_x"}},
+    })
+    with patch("lark_channel.channel.bot_identity._verify_auth", side_effect=_fake_verify), \
+         patch("lark_channel.channel.bot_identity.Transport.aexecute",
+               new=AsyncMock(return_value=bot_v3_resp)):
+        ident = await fetch_bot_identity(config)
+    assert isinstance(ident, BotIdentity)
+    assert ident.open_id == "ou_bot_1"
+    assert ident.name == "Demo Bot"
+    assert ident.user_id == "u1"
+
+
+@pytest.mark.asyncio
+async def test_fetch_falls_back_to_application_get():
+    config = Config()
+    config.app_id = "cli_y"
+    config.app_secret = "sec"
+
+    bot_v3_fail = _raw({"code": 99999, "msg": "blocked"})
+    app_resp = _raw({
+        "code": 0,
+        "data": {"app": {"app_name": "App Y", "bot_info": {"open_id": "ou_fallback"}}},
+    })
+    calls = [bot_v3_fail, app_resp]
+
+    async def fake_aexecute(cfg, req, opt):
+        return calls.pop(0)
+
+    with patch("lark_channel.channel.bot_identity._verify_auth", side_effect=_fake_verify), \
+         patch("lark_channel.channel.bot_identity.Transport.aexecute", side_effect=fake_aexecute):
+        ident = await fetch_bot_identity(config)
+    assert ident is not None and ident.open_id == "ou_fallback"
+    assert ident.name == "App Y"
+
+
+@pytest.mark.asyncio
+async def test_fetch_returns_none_on_all_failures():
+    config = Config()
+    config.app_id = "cli_z"
+    config.app_secret = "sec"
+
+    with patch("lark_channel.channel.bot_identity._verify_auth", side_effect=_fake_verify), \
+         patch("lark_channel.channel.bot_identity.Transport.aexecute",
+               new=AsyncMock(side_effect=RuntimeError("network"))):
+        ident = await fetch_bot_identity(config)
+    assert ident is None
+
+
+@pytest.mark.asyncio
+async def test_fetch_handles_top_level_payload():
+    """Regression: /bot/v3/info returns {bot, code, msg} with no `data`
+    envelope — unlike most Feishu OpenAPI endpoints. The parser must
+    unwrap both shapes or the fetch fails silently even on HTTP 200.
+    """
+    config = Config()
+    config.app_id = "cli_t"
+    config.app_secret = "sec"
+
+    # Real shape observed from the production /bot/v3/info endpoint.
+    flat_resp = _raw({
+        "bot": {
+            "open_id": "ou_real_bot",
+            "app_name": "Demo Bot",
+            "activate_status": 2,
+        },
+        "code": 0,
+        "msg": "ok",
+    })
+    with patch("lark_channel.channel.bot_identity._verify_auth", side_effect=_fake_verify), \
+         patch("lark_channel.channel.bot_identity.Transport.aexecute",
+               new=AsyncMock(return_value=flat_resp)):
+        ident = await fetch_bot_identity(config)
+
+    assert ident is not None, "flat payload must be parsed, not treated as failure"
+    assert ident.open_id == "ou_real_bot"
+    assert ident.name == "Demo Bot"
+
+
+@pytest.mark.asyncio
+async def test_fetch_injects_tenant_token_into_request():
+    """Regression: `fetch_bot_identity` must run the auth-verify step before
+    calling `Transport.aexecute`. Without it, `option.tenant_access_token`
+    stays None and the outbound header becomes literal ``Bearer None``, which
+    Feishu rejects with 400 — leaving bot identity unresolved and breaking
+    group @Bot detection.
+    """
+    config = Config()
+    config.app_id = "cli_w"
+    config.app_secret = "sec"
+
+    bot_v3_resp = _raw({
+        "code": 0,
+        "data": {"bot": {"open_id": "ou_bot", "app_id": "cli_w"}},
+    })
+
+    captured = {}
+
+    async def spy_aexecute(cfg, req, opt):
+        # Record the option.tenant_access_token that the caller prepared.
+        captured["token"] = opt.tenant_access_token
+        return bot_v3_resp
+
+    # Stub `verify` so we don't actually hit the token endpoint but we *do*
+    # observe that the verify step is invoked with the same (req, option)
+    # that later reaches aexecute.
+    with patch("lark_channel.channel.bot_identity._verify_auth", side_effect=_fake_verify) as verify_mock, \
+         patch("lark_channel.channel.bot_identity.Transport.aexecute", side_effect=spy_aexecute):
+        ident = await fetch_bot_identity(config)
+
+    assert ident is not None and ident.open_id == "ou_bot"
+    # Verify was actually called before aexecute (otherwise the captured
+    # token would be None).
+    assert verify_mock.called, "fetch_bot_identity must invoke token.auth.verify"
+    assert captured["token"] == "t-test", (
+        "tenant token must be set on option before aexecute — otherwise the "
+        "request goes out with `Bearer None`"
+    )
diff --git a/lark_channel/channel/tests/test_card_builder.py b/lark_channel/channel/tests/test_card_builder.py
new file mode 100644
index 0000000..7ce1767
--- /dev/null
+++ b/lark_channel/channel/tests/test_card_builder.py
@@ -0,0 +1,119 @@
+"""Card builder tests."""
+
+from lark_channel.channel.card.builder import card
+
+
+def test_minimal_card():
+    c = card().markdown("hi").build()
+    assert c.version == "v2"
+    assert c.data["schema"] == "2.0"
+    assert c.data["body"]["elements"][0] == {"tag": "markdown", "content": "hi"}
+
+
+def test_header():
+    c = card().header(title="H", subtitle="sub", template="blue").markdown("x").build()
+    assert c.data["header"]["title"]["content"] == "H"
+    assert c.data["header"]["subtitle"]["content"] == "sub"
+    assert c.data["header"]["template"] == "blue"
+
+
+def test_button_emitted_as_top_level_v2():
+    c = (
+        card()
+        .button(label="Approve", action={"type": "approve"}, style="primary")
+        .build()
+    )
+    el = c.data["body"]["elements"][0]
+    # CardKit v2 dropped the `action` wrapper — button is top-level
+    assert el["tag"] == "button"
+    assert el["type"] == "primary"
+    assert el["value"] == {"type": "approve"}
+    assert el["text"]["content"] == "Approve"
+
+
+def test_divider_and_image():
+    c = card().divider().image("img_x", alt="A").build()
+    body = c.data["body"]["elements"]
+    assert body[0]["tag"] == "hr"
+    assert body[1]["tag"] == "img"
+    assert body[1]["img_key"] == "img_x"
+
+
+def test_raw_passthrough():
+    c = card().raw({"tag": "custom_element", "payload": 1}).build()
+    assert c.data["body"]["elements"][0] == {"tag": "custom_element", "payload": 1}
+
+
+def test_column_set_embeds_subbuilder_elements():
+    col = card().markdown("a")
+    col2 = card().markdown("b")
+    c = card().column_set([col, col2]).build()
+    cs = c.data["body"]["elements"][0]
+    assert cs["tag"] == "column_set"
+    assert len(cs["columns"]) == 2
+    assert cs["columns"][0]["elements"][0]["content"] == "a"
+
+
+def test_progress_bar_renders_percent():
+    c = card().progress(42, label="Deploying").build()
+    md = c.data["body"]["elements"][0]["content"]
+    assert "42%" in md
+
+
+def test_streaming_flag_sets_config():
+    c = card().streaming(True).markdown("...").build()
+    assert c.data["config"].get("streaming_mode") is True
+
+
+def test_table_emits_native_table_component():
+    # Previously `.table()` stuffed a GFM pipe-table into a markdown element
+    # where Feishu silently drops pipe syntax. It must now emit the native
+    # Card 2.0 `table` component.
+    c = card().table(
+        headers=["Name", "Score"],
+        rows=[["Alice", "90"], ["Bob", "80"]],
+    ).build()
+    el = c.data["body"]["elements"][0]
+    assert el["tag"] == "table"
+    assert el["columns"] == [
+        {"name": "col_0", "display_name": "Name", "data_type": "text"},
+        {"name": "col_1", "display_name": "Score", "data_type": "text"},
+    ]
+    assert el["rows"] == [
+        {"col_0": "Alice", "col_1": "90"},
+        {"col_0": "Bob", "col_1": "80"},
+    ]
+
+
+def test_table_auto_picks_lark_md_for_inline_markdown():
+    c = card().table(
+        headers=["Name", "Status"],
+        rows=[["**Alice**", "ok"], ["Bob", "`done`"]],
+    ).build()
+    cols = c.data["body"]["elements"][0]["columns"]
+    assert cols[0]["data_type"] == "lark_md"  # **Alice**
+    assert cols[1]["data_type"] == "lark_md"  # `done`
+
+
+def test_table_pads_short_rows_and_clamps_page_size():
+    c = card().table(
+        headers=["a", "b", "c"],
+        rows=[["1"], ["2", "3", "4", "5"]],
+        page_size=99,
+    ).build()
+    el = c.data["body"]["elements"][0]
+    assert el["page_size"] == 10
+    assert el["rows"] == [
+        {"col_0": "1", "col_1": "", "col_2": ""},
+        {"col_0": "2", "col_1": "3", "col_2": "4"},
+    ]
+
+
+def test_table_rejects_mismatched_data_types():
+    import pytest
+    with pytest.raises(ValueError):
+        card().table(
+            headers=["a", "b"],
+            rows=[["1", "2"]],
+            data_types=["text"],
+        )
diff --git a/lark_channel/channel/tests/test_cardkit_preallocation.py b/lark_channel/channel/tests/test_cardkit_preallocation.py
new file mode 100644
index 0000000..a56888e
--- /dev/null
+++ b/lark_channel/channel/tests/test_cardkit_preallocation.py
@@ -0,0 +1,111 @@
+"""Cardkit preallocation API tests (node-aligned).
+
+Covers :meth:`FeishuChannel.create_card_instance`,
+:meth:`send_card_by_reference`, :meth:`update_card_element_content`,
+:meth:`finish_streaming_card`.
+"""
+
+import json
+from unittest.mock import AsyncMock
+
+import pytest
+
+from lark_channel.channel import FeishuChannel
+from lark_channel.channel.errors import FeishuChannelError
+
+
+@pytest.fixture
+def channel() -> FeishuChannel:
+    return FeishuChannel(app_id="cli_x", app_secret="s")
+
+
+@pytest.mark.asyncio
+async def test_create_card_instance_returns_card_id(channel):
+    channel._driver.cardkit_create = AsyncMock(
+        return_value={"code": 0, "data": {"card_id": "AAQ_card_xyz"}}
+    )
+    cid = await channel.create_card_instance({"schema": "2.0"})
+    assert cid == "AAQ_card_xyz"
+    call = channel._driver.cardkit_create.await_args
+    body = call.kwargs["body"]
+    assert body["type"] == "card_json"
+    assert json.loads(body["data"]) == {"schema": "2.0"}
+
+
+@pytest.mark.asyncio
+async def test_create_card_instance_failure_raises(channel):
+    channel._driver.cardkit_create = AsyncMock(
+        return_value={"code": 400, "msg": "bad spec"}
+    )
+    with pytest.raises(FeishuChannelError):
+        await channel.create_card_instance({"schema": "2.0"})
+
+
+@pytest.mark.asyncio
+async def test_create_card_instance_missing_id_raises(channel):
+    channel._driver.cardkit_create = AsyncMock(return_value={"code": 0, "data": {}})
+    with pytest.raises(FeishuChannelError):
+        await channel.create_card_instance({"schema": "2.0"})
+
+
+@pytest.mark.asyncio
+async def test_send_card_by_reference_builds_interactive_message(channel):
+    channel._sender.send = AsyncMock()
+    await channel.send_card_by_reference("oc_chat_1", "card_abc")
+    call = channel._sender.send.await_args
+    sent = call.args[0]
+    # OutboundCard with the reference-shape card payload
+    assert sent.card == {"type": "card", "data": {"card_id": "card_abc"}}
+    assert call.kwargs["receive_id"] == "oc_chat_1"
+    assert call.kwargs["receive_id_type"] == "chat_id"
+
+
+@pytest.mark.asyncio
+async def test_send_card_by_reference_explicit_receive_type(channel):
+    channel._sender.send = AsyncMock()
+    await channel.send_card_by_reference(
+        "user@example.com", "card_abc", receive_id_type="email"
+    )
+    assert channel._sender.send.await_args.kwargs["receive_id_type"] == "email"
+
+
+@pytest.mark.asyncio
+async def test_update_card_element_content_passes_sequence(channel):
+    channel._driver.cardkit_update_element = AsyncMock(return_value={"code": 0})
+    await channel.update_card_element_content(
+        "card_abc", "el_1", "hello world", 7
+    )
+    call = channel._driver.cardkit_update_element.await_args
+    assert call.kwargs["card_id"] == "card_abc"
+    assert call.kwargs["element_id"] == "el_1"
+    assert call.kwargs["body"] == {"content": "hello world", "sequence": 7}
+
+
+@pytest.mark.asyncio
+async def test_update_card_element_content_failure_raises(channel):
+    channel._driver.cardkit_update_element = AsyncMock(
+        return_value={"code": 400, "msg": "sequence out-of-order"}
+    )
+    with pytest.raises(FeishuChannelError):
+        await channel.update_card_element_content("card_abc", "el_1", "...", 2)
+
+
+@pytest.mark.asyncio
+async def test_finish_streaming_card_posts_streaming_false(channel):
+    channel._driver.cardkit_update_settings = AsyncMock(return_value={"code": 0})
+    await channel.finish_streaming_card("card_abc", 99)
+    call = channel._driver.cardkit_update_settings.await_args
+    assert call.kwargs["card_id"] == "card_abc"
+    body = call.kwargs["body"]
+    assert body["sequence"] == 99
+    parsed = json.loads(body["settings"])
+    assert parsed == {"config": {"streaming_mode": False}}
+
+
+@pytest.mark.asyncio
+async def test_finish_streaming_card_failure_raises(channel):
+    channel._driver.cardkit_update_settings = AsyncMock(
+        return_value={"code": 400, "msg": "sequence out-of-order"}
+    )
+    with pytest.raises(FeishuChannelError):
+        await channel.finish_streaming_card("card_abc", 1)
diff --git a/lark_channel/channel/tests/test_channel_low_level.py b/lark_channel/channel/tests/test_channel_low_level.py
new file mode 100644
index 0000000..26a332b
--- /dev/null
+++ b/lark_channel/channel/tests/test_channel_low_level.py
@@ -0,0 +1,364 @@
+"""Low-level FeishuChannel helpers: recall / add_reaction / update_card /
+download_resource / disconnect / client accessors."""
+
+import json
+from unittest.mock import AsyncMock
+
+import pytest
+
+from lark_channel.channel import FeishuChannel
+
+
+@pytest.fixture
+def channel():
+    return FeishuChannel(app_id="cli_x", app_secret="s")
+
+
+@pytest.mark.asyncio
+async def test_update_card_calls_underlying_patch(channel):
+    channel._driver.patch_message = AsyncMock(return_value={"code": 0})
+    r = await channel.update_card("om_1", {"schema": "2.0"})
+    assert r.success is True
+    channel._driver.patch_message.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+async def test_update_card_failure_returns_failed_result(channel):
+    channel._driver.patch_message = AsyncMock(
+        return_value={"code": 230001, "msg": "invalid card"}
+    )
+    r = await channel.update_card("om_1", {"schema": "2.0"})
+    assert r.success is False
+    assert r.error is not None
+    assert r.error.raw_code == 230001
+    assert r.raw == {"code": 230001, "msg": "invalid card"}
+
+
+@pytest.mark.asyncio
+async def test_recall_message_success(channel):
+    channel._driver.delete_message = AsyncMock(return_value={"code": 0})
+    r = await channel.recall_message("om_2")
+    assert r.success is True
+
+
+@pytest.mark.asyncio
+async def test_recall_message_failure_surfaces(channel):
+    channel._driver.delete_message = AsyncMock(return_value={"code": 230002, "msg": "not exist"})
+    r = await channel.recall_message("om_missing")
+    assert r.success is False
+    assert r.error is not None
+
+
+@pytest.mark.asyncio
+async def test_add_reaction_success(channel):
+    channel._driver.add_reaction = AsyncMock(return_value={"code": 0})
+    r = await channel.add_reaction("om_1", "THUMBSUP")
+    assert r.success is True
+
+
+@pytest.mark.asyncio
+async def test_remove_reaction_success(channel):
+    channel._driver.remove_reaction = AsyncMock(return_value={"code": 0})
+    r = await channel.remove_reaction("om_1", "rxn_1")
+    assert r.success is True
+
+
+@pytest.mark.asyncio
+async def test_remove_reaction_by_emoji_lists_then_deletes_first_match(channel):
+    channel._driver.list_reactions = AsyncMock(
+        return_value={
+            "code": 0,
+            "data": {
+                "items": [
+                    {"reaction_id": "r1", "reaction_type": {"emoji_type": "SMILE"}},
+                    {"reaction_id": "r2", "reaction_type": {"emoji_type": "THUMBSUP"}},
+                ]
+            },
+        }
+    )
+    channel._driver.remove_reaction = AsyncMock(return_value={"code": 0})
+
+    result = await channel.remove_reaction_by_emoji("om_1", "THUMBSUP")
+
+    assert result.success is True
+    channel._driver.list_reactions.assert_awaited_once_with(
+        message_id="om_1",
+        emoji_type="THUMBSUP",
+        page_token=None,
+        page_size=None,
+    )
+    channel._driver.remove_reaction.assert_awaited_once_with(
+        message_id="om_1",
+        reaction_id="r2",
+    )
+
+
+@pytest.mark.asyncio
+async def test_remove_reaction_by_emoji_returns_failed_result_when_no_match(channel):
+    channel._driver.list_reactions = AsyncMock(
+        return_value={"code": 0, "data": {"items": []}}
+    )
+
+    result = await channel.remove_reaction_by_emoji("om_1", "SMILE")
+
+    assert result.success is False
+    assert result.error is not None
+
+
+@pytest.mark.asyncio
+async def test_fetch_inbound_message_returns_normalized_message_without_changing_fetch_message(channel):
+    raw = {
+        "code": 0,
+        "data": {
+            "items": [
+                {
+                    "message_id": "om_1",
+                    "create_time": "123",
+                    "chat_id": "oc_1",
+                    "chat_type": "group",
+                    "message_type": "text",
+                    "content": json.dumps({"text": "hello @_user_1"}),
+                    "mentions": [
+                        {"key": "@_user_1", "id": {"open_id": "ou_bot"}, "name": "Bot"}
+                    ],
+                    "sender": {
+                        "sender_id": {"open_id": "ou_sender", "user_id": "u1"},
+                        "sender_type": "user",
+                    },
+                }
+            ]
+        },
+    }
+    channel._driver.fetch_message = AsyncMock(return_value=raw)
+    channel._pipeline.set_bot_open_id("ou_bot")
+
+    assert await channel.fetch_message("om_1") == raw
+    inbound = await channel.fetch_inbound_message("om_1")
+
+    assert inbound is not None
+    assert inbound.id == "om_1"
+    assert inbound.content_text == "hello @Bot"
+    assert inbound.mentioned_bot is True
+    assert inbound.raw["message_id"] == "om_1"
+
+
+@pytest.mark.asyncio
+async def test_fetch_inbound_message_handles_get_message_sender_id_type(channel):
+    raw = {
+        "code": 0,
+        "data": {
+            "items": [
+                {
+                    "message_id": "om_1",
+                    "create_time": 123,
+                    "chat_id": "oc_1",
+                    "msg_type": "text",
+                    "body": {"content": json.dumps({"text": "hello"})},
+                    "sender": {
+                        "id": "u_sender",
+                        "id_type": "user_id",
+                        "sender_type": "user",
+                    },
+                    "mentions": [],
+                }
+            ]
+        },
+    }
+    channel._driver.fetch_message = AsyncMock(return_value=raw)
+
+    inbound = await channel.fetch_inbound_message("om_1")
+
+    assert inbound is not None
+    assert inbound.content_text == "hello"
+    assert inbound.sender.open_id == ""
+    assert inbound.sender.user_id == "u_sender"
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("id_type", ["open_id", None])
+async def test_fetch_inbound_message_maps_open_id_sender_variants(channel, id_type):
+    sender = {
+        "id": "ou_sender",
+        "sender_type": "user",
+    }
+    if id_type is not None:
+        sender["id_type"] = id_type
+    raw = {
+        "code": 0,
+        "data": {
+            "items": [
+                {
+                    "message_id": "om_1",
+                    "create_time": 123,
+                    "chat_id": "oc_1",
+                    "msg_type": "text",
+                    "body": {"content": json.dumps({"text": "hello"})},
+                    "sender": sender,
+                    "mentions": [],
+                }
+            ]
+        },
+    }
+    channel._driver.fetch_message = AsyncMock(return_value=raw)
+
+    inbound = await channel.fetch_inbound_message("om_1")
+
+    assert inbound is not None
+    assert inbound.sender.open_id == "ou_sender"
+    assert inbound.sender.user_id is None
+
+
+@pytest.mark.asyncio
+async def test_fetch_inbound_message_bypasses_pipeline_dedup(channel):
+    message = {
+        "message_id": "om_dedup",
+        "create_time": "123",
+        "chat_id": "oc_1",
+        "chat_type": "p2p",
+        "message_type": "text",
+        "content": json.dumps({"text": "hello"}),
+        "mentions": [],
+    }
+    sender = {
+        "sender_id": {"open_id": "ou_sender", "user_id": "u1"},
+        "sender_type": "user",
+    }
+
+    first = await channel._pipeline.process(
+        event_id="e1",
+        message_event=message,
+        sender=sender,
+    )
+    duplicate = await channel._pipeline.process(
+        event_id="e2",
+        message_event=message,
+        sender=sender,
+    )
+    channel._driver.fetch_message = AsyncMock(
+        return_value={"code": 0, "data": {"items": [{**message, "sender": sender}]}}
+    )
+
+    fetched = await channel.fetch_inbound_message("om_dedup")
+
+    assert first is not None
+    assert duplicate is None
+    assert fetched is not None
+    assert fetched.id == "om_dedup"
+
+
+@pytest.mark.asyncio
+async def test_download_resource_delegates_to_hook(channel):
+    channel._download_media = AsyncMock(return_value=b"\x89PNG...")
+    data = await channel.download_resource("img_xxx", resource_type="image")
+    assert data == b"\x89PNG..."
+
+
+def test_client_exposes_underlying():
+    channel = FeishuChannel(app_id="cli_x", app_secret="s")
+    assert channel.client is channel._client
+
+
+def test_dispatcher_accessor_triggers_build():
+    channel = FeishuChannel(app_id="cli_x", app_secret="s")
+    channel._ensure_bg_loop()
+    d = channel.dispatcher
+    assert d is not None
+
+
+def test_bot_identity_accessor_default_none():
+    channel = FeishuChannel(app_id="cli_x", app_secret="s")
+    assert channel.bot_identity is None
+
+
+def test_update_policy_syncs_into_channel_config():
+    channel = FeishuChannel(app_id="cli_x", app_secret="s")
+    channel._ensure_bg_loop()  # spin safety up
+    channel.update_policy(dm_policy="disabled", require_mention=False)
+    assert channel.get_policy().dm_policy == "disabled"
+    assert channel.get_policy().require_mention is False
+
+
+@pytest.mark.asyncio
+async def test_disconnect_drains_safety_and_stops():
+    channel = FeishuChannel(app_id="cli_x", app_secret="s")
+    channel._ensure_bg_loop()
+    await channel.disconnect()
+    # After disconnect() the bg loop + ws client + thread are torn down,
+    # and the started flag is reset so a subsequent connect() can re-run.
+    # ``_shutdown`` is cleared at the end of stop() so the channel can be
+    # reconnected later; we assert on the
+    # observable state that actually matters.
+    assert channel._bg_loop is None
+    assert channel._ws_client is None
+    assert channel._started is False
+
+
+@pytest.mark.asyncio
+async def test_connect_is_idempotent_when_started():
+    channel = FeishuChannel(app_id="cli_x", app_secret="s")
+    channel._started = True  # pretend start() already ran
+    # Should return quickly without attempting to start WS
+    await channel.connect()
+
+
+@pytest.mark.asyncio
+async def test_send_stream_unknown_kind_raises():
+    channel = FeishuChannel(app_id="cli_x", app_secret="s")
+    with pytest.raises(TypeError):
+        await channel.stream("oc_x", {"nonsense": "body"})
+
+
+@pytest.mark.asyncio
+async def test_send_unknown_keys_raises():
+    from lark_channel.channel._coerce import coerce_outbound as _coerce_outbound
+    with pytest.raises(TypeError):
+        _coerce_outbound({"unknown_key": "x"})
+
+
+@pytest.mark.asyncio
+async def test_send_media_buffer_coercion():
+    from lark_channel.channel._coerce import coerce_outbound as _coerce_outbound
+    from lark_channel.channel.types import OutboundFile
+    ob = _coerce_outbound({"file": {"source": b"\x01\x02", "fileName": "f.bin"}})
+    assert isinstance(ob, OutboundFile)
+    assert ob.source.kind == "buffer"
+
+
+@pytest.mark.asyncio
+async def test_send_media_source_media_ref_passes_through():
+    from lark_channel.channel._coerce import coerce_outbound as _coerce_outbound
+    from lark_channel.channel.types import MediaSource, OutboundImage
+    ob = _coerce_outbound({"image": {"source": MediaSource(kind="key", key="img_x")}})
+    assert isinstance(ob, OutboundImage)
+    assert ob.source.key == "img_x"
+
+
+@pytest.mark.asyncio
+async def test_send_markdown_stream_invokes_producer(channel):
+    # MarkdownStream now uses the CardKit preallocation flow — mock the 4
+    # channel methods it calls. Verify seq-ordered element updates + finish.
+    channel.create_card_instance = AsyncMock(return_value="card_xyz")
+
+    from lark_channel.channel.types import SendResult as _SR
+    channel.send_card_by_reference = AsyncMock(
+        return_value=_SR.ok(message_id="om_fake_stream"),
+    )
+    channel.update_card_element_content = AsyncMock(return_value=None)
+    channel.finish_streaming_card = AsyncMock(return_value=None)
+
+    got_controller = []
+
+    async def producer(s):
+        got_controller.append(s)
+        await s.append("hello")
+
+    result = await channel.stream("oc_1", {"markdown": producer})
+    assert result.success is True
+    assert result.message_id == "om_fake_stream"
+    assert got_controller  # producer ran
+    channel.create_card_instance.assert_awaited_once()
+    channel.send_card_by_reference.assert_awaited_once()
+    channel.finish_streaming_card.assert_awaited_once()
+    # At least one element update was issued via the seq-ordered API,
+    # NOT via the generic patch API.
+    assert channel.update_card_element_content.await_count >= 1
diff --git a/lark_channel/channel/tests/test_chunker.py b/lark_channel/channel/tests/test_chunker.py
new file mode 100644
index 0000000..fd84fe9
--- /dev/null
+++ b/lark_channel/channel/tests/test_chunker.py
@@ -0,0 +1,38 @@
+"""Tests for the outbound text chunker."""
+
+from lark_channel.channel.outbound.sender import chunk_text
+
+
+def test_short_text_passthrough():
+    assert chunk_text("hi", limit=4000) == ["hi"]
+
+
+def test_empty_returns_empty_list():
+    assert chunk_text("", limit=4000) == []
+
+
+def test_newline_boundary():
+    body = "abc\n" * 100  # 400 chars
+    chunks = chunk_text(body, limit=50, mode="newline")
+    assert all(len(c) <= 50 for c in chunks)
+    # Re-joining with the delimiter should yield original (minus trimmed trailing)
+    joined = "\n".join(chunks)
+    # Accept either trailing newline or not — reconstruction is approximate.
+    assert joined.replace("\n", "") == body.replace("\n", "")
+
+
+def test_hard_cut_when_no_delimiter():
+    body = "x" * 123
+    chunks = chunk_text(body, limit=30, mode="newline")
+    assert chunks == ["x" * 30, "x" * 30, "x" * 30, "x" * 30, "x" * 3]
+
+
+def test_paragraph_mode():
+    body = "para1 line1\npara1 line2\n\npara2 line1\n\npara3"
+    chunks = chunk_text(body, limit=20, mode="paragraph")
+    assert chunks
+
+
+def test_none_mode_hard_cut():
+    chunks = chunk_text("abcdefghij", limit=3, mode="none")
+    assert chunks == ["abc", "def", "ghi", "j"]
diff --git a/lark_channel/channel/tests/test_client_handlers.py b/lark_channel/channel/tests/test_client_handlers.py
new file mode 100644
index 0000000..3166854
--- /dev/null
+++ b/lark_channel/channel/tests/test_client_handlers.py
@@ -0,0 +1,316 @@
+"""FeishuChannel's per-event async handlers — exercised with fake P2 payloads.
+
+Drives `_handle_*_event` directly, bypassing the WS / dispatcher layer.
+Uses the public `channel.on("event_name", handler)` registration API.
+"""
+
+import json
+from types import SimpleNamespace
+
+import pytest
+
+from lark_channel.channel import FeishuChannel as _ChannelClient
+from lark_channel.channel.config import InboundConfig
+from lark_channel.channel.safety import RejectEvent
+from lark_channel.api.im.v1.model.p2_im_message_reaction_created_v1 import (
+    P2ImMessageReactionCreatedV1,
+)
+from lark_channel.channel.types import CardActionPayload
+from lark_channel.event.callback.model.p2_card_action_trigger import P2CardActionTrigger
+
+
+def _client(**kwargs):
+    return _ChannelClient(app_id="cli_x", app_secret="s", **kwargs)
+
+
+# ---- interaction handler -------------------------------------------------
+
+
+def _fake_card_action(*, action_value, tag="button", message_id="om_xyz",
+                      operator_open_id="ou_op"):
+    """SimpleNamespace mimicking P2CardActionTrigger attribute tree (bypasses
+    the generated model's strict typing that forbids string action.value)."""
+    return SimpleNamespace(
+        event=SimpleNamespace(
+            action=SimpleNamespace(tag=tag, value=action_value),
+            operator=SimpleNamespace(open_id=operator_open_id),
+            context=SimpleNamespace(open_message_id=message_id),
+        ),
+    )
+
+
+@pytest.mark.asyncio
+async def test_handle_interaction_event_passes_parsed_action():
+    c = _client()
+    got = []
+    c.on("cardAction", lambda event: got.append(event))
+    data = _fake_card_action(action_value=json.dumps({"kind": "rate", "score": "up"}))
+    await c._handle_interaction_event(data)
+    assert len(got) == 1
+    event = got[0]
+    assert event.action.value == {"kind": "rate", "score": "up"}
+    assert event.message_id == "om_xyz"
+    assert event.operator.open_id == "ou_op"
+    assert event.action.tag == "button"
+
+
+@pytest.mark.asyncio
+async def test_handle_interaction_event_non_json_value_wrapped():
+    c = _client()
+    got = []
+    c.on("cardAction", lambda event: got.append(event))
+    data = _fake_card_action(action_value="plain-string-not-json")
+    await c._handle_interaction_event(data)
+    assert got[0].action.value == {"value": "plain-string-not-json"}
+
+
+@pytest.mark.asyncio
+async def test_handle_interaction_event_exposes_cardkit_form_fields():
+    c = _client()
+    got = []
+    c.on("cardAction", lambda event: got.append(event))
+    data = SimpleNamespace(
+        event=SimpleNamespace(
+            action=SimpleNamespace(
+                tag="form",
+                value={"legacy": "v"},
+                form_value={"field": "value"},
+                input_value="typed",
+                options=["a", "b"],
+                checked=True,
+            ),
+            operator=SimpleNamespace(open_id="ou_op"),
+            context=SimpleNamespace(open_message_id="om_xyz", open_chat_id="oc_1"),
+        ),
+    )
+
+    await c._handle_interaction_event(data)
+
+    assert got[0].action.value == {"legacy": "v"}
+    assert got[0].action.form_value == {"field": "value"}
+    assert got[0].action.input_value == "typed"
+    assert got[0].action.options == ["a", "b"]
+    assert got[0].action.checked is True
+
+
+def test_card_action_payload_form_fields_do_not_affect_equality_or_repr():
+    a = CardActionPayload(tag="form", value={"legacy": "v"})
+    b = CardActionPayload(
+        tag="form",
+        value={"legacy": "v"},
+        form_value={"field": "value"},
+        input_value="typed",
+        options=["a"],
+        checked=True,
+    )
+
+    assert a == b
+    text = repr(b)
+    assert "form_value" not in text
+    assert "input_value" not in text
+    assert "options" not in text
+    assert "checked" not in text
+
+
+@pytest.mark.asyncio
+async def test_handle_interaction_event_no_handler_is_noop():
+    c = _client()
+    # No cardAction handler registered — shouldn't raise
+    data = P2CardActionTrigger({"event": {}})
+    await c._handle_interaction_event(data)
+
+
+# ---- raw handler ---------------------------------------------------------
+
+
+def _fake_message_event(message_id="om_raw"):
+    return SimpleNamespace(
+        header=SimpleNamespace(event_id="evt_raw"),
+        event=SimpleNamespace(
+            sender=SimpleNamespace(
+                sender_id=SimpleNamespace(open_id="ou_sender", user_id="u1"),
+                sender_type="user",
+            ),
+            message=SimpleNamespace(
+                message_id=message_id,
+                create_time="1000",
+                chat_id="oc_1",
+                chat_type="p2p",
+                message_type="text",
+                content=json.dumps({"text": "hello"}),
+                mentions=[],
+            ),
+        ),
+    )
+
+
+@pytest.mark.asyncio
+async def test_handle_message_event_does_not_emit_raw_by_default():
+    c = _client()
+    raw_events = []
+    messages = []
+    c.on("raw", lambda event: raw_events.append(event))
+    c.on("message", lambda event: messages.append(event))
+
+    await c._handle_message_event(_fake_message_event())
+
+    assert len(messages) == 1
+    assert raw_events == []
+
+
+@pytest.mark.asyncio
+async def test_handle_message_event_emits_raw_when_enabled():
+    c = _client(inbound=InboundConfig(emit_raw_events=True))
+    raw_events = []
+    c.on("raw", lambda event: raw_events.append(event))
+
+    await c._handle_message_event(_fake_message_event())
+
+    assert len(raw_events) == 1
+    assert raw_events[0]["event"]["message"]["message_id"] == "om_raw"
+
+
+# ---- reaction handler ---------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_handle_reaction_event_off_mode_drops():
+    c = _client()
+    c._config.inbound.reaction_notifications = "off"
+    got = []
+    c.on("reaction", lambda event: got.append(event))
+    data = P2ImMessageReactionCreatedV1({
+        "event": {
+            "message_id": "om_1",
+            "reaction_type": {"emoji_type": "HEART"},
+            "user_id": {"open_id": "ou_r"},
+        },
+    })
+    await c._handle_reaction_event(data, action="create")
+    assert got == []
+
+
+# ---- bot add / leave handlers -------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_handle_bot_event_join_dispatches():
+    c = _client()
+    got = []
+    c.on("botAdded", lambda event: got.append(event))
+
+    data = SimpleNamespace(
+        event=SimpleNamespace(
+            chat_id="oc_new",
+            operator_id=SimpleNamespace(open_id="ou_op"),
+        ),
+    )
+    await c._handle_bot_event(data, joined=True)
+    assert len(got) == 1
+    assert got[0].chat_id == "oc_new"
+    assert got[0].operator.open_id == "ou_op"
+
+
+@pytest.mark.asyncio
+async def test_handle_bot_event_leave_dispatches_when_handler_set():
+    c = _client()
+    got = []
+    c.on("botLeave", lambda event: got.append(event))
+
+    data = SimpleNamespace(
+        event=SimpleNamespace(chat_id="oc_gone", operator_id=None),
+    )
+    await c._handle_bot_event(data, joined=False)
+    assert len(got) == 1
+
+
+@pytest.mark.asyncio
+async def test_handle_bot_event_no_handler_noop():
+    c = _client()
+    data = SimpleNamespace(event=SimpleNamespace(chat_id="oc_x", operator_id=None))
+    await c._handle_bot_event(data, joined=True)  # no raise
+
+
+# ---- message_read handler -----------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_handle_message_read_event_dispatches():
+    c = _client()
+    got = []
+    c.on("messageRead", lambda event: got.append(event))
+    data = SimpleNamespace(event=SimpleNamespace(
+        reader=SimpleNamespace(reader_id=SimpleNamespace(open_id="ou_reader")),
+        message_id_list=["om_1", "om_2"],
+    ))
+    await c._handle_message_read_event(data)
+    assert len(got) == 1
+    assert got[0].message_ids == ["om_1", "om_2"]
+    assert got[0].reader.open_id == "ou_reader"
+
+
+# ---- require_user_auth error paths --------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_require_user_auth_raises_when_scope_blocked():
+    from lark_channel.channel.errors import UATAuthError
+
+    c = _client()
+    c._config.uat.blocked_scopes = ["im:admin"]
+    with pytest.raises(UATAuthError):
+        await c.require_user_auth("ou_user", ["im:admin"])
+
+
+@pytest.mark.asyncio
+async def test_require_user_auth_raises_when_scope_not_allowed():
+    from lark_channel.channel.errors import UATAuthError
+
+    c = _client()
+    c._config.uat.allowed_scopes = ["im:message"]
+    with pytest.raises(UATAuthError):
+        await c.require_user_auth("ou_user", ["wiki:write"])
+
+
+@pytest.mark.asyncio
+async def test_require_user_auth_returns_existing_uat_when_fresh():
+    import time
+    from lark_channel.channel.types import UAT
+
+    c = _client()
+    fresh = UAT(
+        access_token="t",
+        refresh_token="r",
+        expires_at=time.time() + 3600,
+        scopes=["im:message"],
+    )
+    await c._token_store.set("ou_me", fresh)
+    got = await c.require_user_auth("ou_me", ["im:message"])
+    assert got is fresh
+
+
+# ---- dispatcher property builds lazily ----------------------------------
+
+
+def test_dispatcher_property_builds_lazily():
+    c = _client()
+    assert c._dispatcher is None
+    d = c.dispatcher
+    assert d is not None
+    assert c._dispatcher is d
+
+
+# ---- _emit_reject with exception in handler is logged, not raised -------
+
+
+def test_emit_reject_handler_exception_is_swallowed(caplog):
+    c = _client()
+
+    def bad(_):
+        raise ValueError("handler bug")
+
+    c.on("reject", bad)
+    c._emit_reject(RejectEvent(
+        message_id="om_x", chat_id="oc_1", sender_id="ou_1", reason="policy_no_mention",
+    ))
+    assert any("raised" in (r.message or "") for r in caplog.records)
diff --git a/lark_channel/channel/tests/test_client_lifecycle.py b/lark_channel/channel/tests/test_client_lifecycle.py
new file mode 100644
index 0000000..2d7aba5
--- /dev/null
+++ b/lark_channel/channel/tests/test_client_lifecycle.py
@@ -0,0 +1,494 @@
+"""Coverage for `_ChannelClient` lifecycle internals without touching the network.
+
+The `start()` method is hard to exercise (opens a WS connection); but the
+pieces it wires up — bg loop, scheduling, sent-message tracking, safety
+pipeline construction, dispatcher building — are all testable in isolation.
+"""
+
+import asyncio
+import threading
+from unittest.mock import patch
+
+import pytest
+
+from lark_channel.channel import FeishuChannel as _ChannelClient
+from lark_channel.channel.bot_identity import BotIdentity
+from lark_channel.channel.config import TransportConfig
+from lark_channel.channel.errors import FeishuChannelError, FeishuChannelErrorCode
+
+
+def _client() -> _ChannelClient:
+    return _ChannelClient(app_id="cli_test", app_secret="sec")
+
+
+def test_build_does_not_spin_up_bg_loop():
+    c = _client()
+    assert c._bg_loop is None
+    assert c._safety is None
+
+
+def test_start_passes_handshake_timeout_to_ws_client():
+    c = _ChannelClient(
+        app_id="cli_test",
+        app_secret="sec",
+        transport=TransportConfig(handshake_timeout_seconds=4.0),
+    )
+    calls = {}
+
+    class _ReadyWS:
+        def __init__(self, *args, **kwargs):
+            calls["kwargs"] = kwargs
+            self._conn = object()
+            self.on_reconnecting = lambda: None
+            self.on_reconnected = lambda: None
+
+        def start(self):
+            return None
+
+        def stop(self):
+            return None
+
+    with patch("lark_channel.channel.channel.WSClient", _ReadyWS), patch.object(
+        c, "_fetch_bot_identity_sync", lambda: None
+    ):
+        c.start()
+        c.stop()
+
+    assert calls["kwargs"]["handshake_timeout"] == 4.0
+
+
+def test_connection_snapshot_initial_state():
+    c = _client()
+
+    snapshot = c.connection_snapshot()
+
+    assert snapshot.state == "idle"
+    assert snapshot.ready is False
+    assert snapshot.reconnect_attempts == 0
+    assert snapshot.last_connected_at is None
+    assert snapshot.last_disconnected_at is None
+    assert snapshot.last_error_at is None
+    assert snapshot.last_error is None
+
+
+def test_connection_snapshot_tracks_reconnect_callbacks():
+    c = _client()
+
+    c._notify_reconnecting()
+    reconnecting = c.connection_snapshot()
+    c._notify_reconnected()
+    reconnected = c.connection_snapshot()
+
+    assert reconnecting.state == "reconnecting"
+    assert reconnecting.reconnect_attempts == 1
+    assert reconnected.state == "connected"
+    assert reconnected.ready is False
+    assert reconnected.last_connected_at is not None
+
+
+def test_ensure_bg_loop_is_idempotent():
+    c = _client()
+    c._ensure_bg_loop()
+    loop = c._bg_loop
+    assert loop is not None
+    assert c._safety is not None
+    c._ensure_bg_loop()   # no-op
+    assert c._bg_loop is loop
+
+
+def test_schedule_runs_coroutine_on_bg_loop():
+    c = _client()
+    done = threading.Event()
+    ran_on = {}
+
+    async def task():
+        ran_on["loop"] = asyncio.get_running_loop()
+        done.set()
+
+    c.schedule(task())
+    assert done.wait(2.0), "coroutine never fired"
+    assert ran_on["loop"] is c._bg_loop
+
+
+def test_track_sent_message_bounded_lru():
+    c = _client()
+    c._sent_messages_max = 3
+    c._track_sent_message("a")
+    c._track_sent_message("b")
+    c._track_sent_message("c")
+    c._track_sent_message("d")  # evicts 'a'
+    assert "a" not in c._sent_messages
+    assert "d" in c._sent_messages
+
+
+def test_track_sent_message_ignores_empty():
+    c = _client()
+    c._track_sent_message("")
+    assert len(c._sent_messages) == 0
+
+
+def test_track_sent_message_refreshes_on_touch():
+    c = _client()
+    c._sent_messages_max = 3
+    c._track_sent_message("a")
+    c._track_sent_message("b")
+    c._track_sent_message("c")
+    # Touch 'a' again — should stay even after next insert evicts oldest
+    c._track_sent_message("a")
+    c._track_sent_message("d")
+    assert "a" in c._sent_messages
+
+
+@pytest.mark.asyncio
+async def test_start_background_returns_after_ws_ready_without_waiting_for_start_exit():
+    c = _client()
+    started = threading.Event()
+    release = threading.Event()
+
+    class _BlockingReadyWS:
+        def __init__(self, *args, **kwargs):
+            self._conn = None
+            self._stopped = False
+
+        def start(self):
+            self._conn = object()
+            started.set()
+            release.wait(timeout=2.0)
+
+        def stop(self):
+            self._stopped = True
+            release.set()
+
+    async def _no_identity(_cfg):
+        return None
+
+    with patch("lark_channel.channel.channel.WSClient", _BlockingReadyWS), patch(
+        "lark_channel.channel.channel.fetch_bot_identity", side_effect=_no_identity
+    ):
+        await asyncio.wait_for(c.start_background(timeout=1.0), timeout=1.0)
+        assert started.is_set()
+        assert c.is_ready is True
+        assert c._start_future is not None
+        assert c._start_future.done() is False
+
+        await c.stop_background()
+        assert c.is_ready is False
+
+
+@pytest.mark.asyncio
+async def test_start_background_propagates_not_connected_startup_failure():
+    c = _client()
+
+    class _FailingWS:
+        def __init__(self, *args, **kwargs):
+            pass
+
+        def start(self):
+            raise RuntimeError("handshake failed")
+
+    async def _no_identity(_cfg):
+        return None
+
+    with patch("lark_channel.channel.channel.WSClient", _FailingWS), patch(
+        "lark_channel.channel.channel.fetch_bot_identity", side_effect=_no_identity
+    ):
+        with pytest.raises(FeishuChannelError) as exc:
+            await c.start_background(timeout=1.0)
+
+    assert exc.value.code is FeishuChannelErrorCode.NOT_CONNECTED
+
+
+@pytest.mark.asyncio
+async def test_stop_background_wakes_in_flight_start_background_waiter():
+    c = _client()
+    start_entered = threading.Event()
+    release_start = threading.Event()
+
+    class _BlockingNotReadyWS:
+        def __init__(self, *args, **kwargs):
+            self._conn = None
+
+        def start(self):
+            start_entered.set()
+            release_start.wait(timeout=2.0)
+
+        def stop(self):
+            release_start.set()
+
+    async def _identity(_cfg):
+        return BotIdentity(open_id="ou_bot")
+
+    with patch("lark_channel.channel.channel.WSClient", _BlockingNotReadyWS), patch(
+        "lark_channel.channel.channel.fetch_bot_identity", side_effect=_identity
+    ):
+        start_task = asyncio.create_task(c.start_background(timeout=10.0))
+        while not start_entered.wait(0.01):
+            await asyncio.sleep(0.01)
+
+        await c.stop_background()
+        await asyncio.wait_for(start_task, timeout=1.0)
+
+    assert c.is_ready is False
+    assert c._started is False
+
+
+@pytest.mark.asyncio
+async def test_start_background_after_stop_waits_for_new_readiness(monkeypatch):
+    c = _client()
+    c.stop()
+    loop = asyncio.get_running_loop()
+    start_future = loop.create_future()
+    submitted = threading.Event()
+
+    def fake_run_in_executor(executor, fn):
+        submitted.set()
+        return start_future
+
+    monkeypatch.setattr(loop, "run_in_executor", fake_run_in_executor)
+
+    start_task = asyncio.create_task(c.start_background(timeout=1.0))
+    while not submitted.wait(0.01):
+        await asyncio.sleep(0.01)
+    await asyncio.sleep(0.05)
+
+    assert start_task.done() is False
+
+    c._mark_ready()
+    start_future.set_result(None)
+    await asyncio.wait_for(start_task, timeout=1.0)
+
+
+def test_stop_during_blocking_start_does_not_surface_late_ws_start_exception():
+    c = _client()
+    ready = threading.Event()
+    release = threading.Event()
+    errors = []
+
+    class _LateFailingWS:
+        def __init__(self, *args, **kwargs):
+            self._conn = None
+
+        def start(self):
+            self._conn = object()
+            ready.set()
+            release.wait(timeout=2.0)
+            raise RuntimeError("loop stopped during shutdown")
+
+        def stop(self):
+            return None
+
+    async def _identity(_cfg):
+        return BotIdentity(open_id="ou_bot")
+
+    with patch("lark_channel.channel.channel.WSClient", _LateFailingWS), patch(
+        "lark_channel.channel.channel.fetch_bot_identity", side_effect=_identity
+    ):
+        def run_start():
+            try:
+                c.start()
+            except Exception as exc:
+                errors.append(exc)
+
+        t = threading.Thread(target=run_start)
+        t.start()
+        assert ready.wait(1.0)
+        c.stop()
+        release.set()
+        t.join(timeout=2.0)
+
+    assert not t.is_alive()
+    assert errors == []
+    assert c._started is False
+    assert c.is_ready is False
+
+
+def test_stop_during_pre_ws_start_prevents_late_ws_creation():
+    c = _client()
+    fetch_entered = threading.Event()
+    release_fetch = threading.Event()
+    ws_started = threading.Event()
+    errors = []
+
+    class _ShouldNotStartWS:
+        def __init__(self, *args, **kwargs):
+            pass
+
+        def start(self):
+            ws_started.set()
+
+    async def _slow_identity(_cfg):
+        fetch_entered.set()
+        await asyncio.get_running_loop().run_in_executor(None, release_fetch.wait)
+        return BotIdentity(open_id="ou_bot")
+
+    with patch("lark_channel.channel.channel.WSClient", _ShouldNotStartWS), patch(
+        "lark_channel.channel.channel.fetch_bot_identity", side_effect=_slow_identity
+    ):
+        def run_start():
+            try:
+                c.start()
+            except Exception as exc:
+                errors.append(exc)
+
+        t = threading.Thread(target=run_start)
+        t.start()
+        assert fetch_entered.wait(1.0)
+        stop_t = threading.Thread(target=c.stop)
+        stop_t.start()
+        release_fetch.set()
+        t.join(timeout=2.0)
+        stop_t.join(timeout=2.0)
+
+    assert not t.is_alive()
+    assert not stop_t.is_alive()
+    assert errors == []
+    assert ws_started.is_set() is False
+    assert c.ws_client is None
+    assert c._started is False
+    assert c.is_ready is False
+
+
+def test_stale_pre_ws_start_cannot_be_uncancelled_by_restart():
+    c = _client()
+    first_fetch_entered = threading.Event()
+    second_fetch_entered = threading.Event()
+    release_first_fetch = threading.Event()
+    release_second_fetch = threading.Event()
+    fetch_count = 0
+    labels_by_thread = {}
+    started_labels = []
+    errors = []
+    lock = threading.Lock()
+
+    class _LabelledWS:
+        def __init__(self, *args, **kwargs):
+            self._conn = object()
+
+        def start(self):
+            with lock:
+                started_labels.append(labels_by_thread.get(threading.get_ident()))
+
+        def stop(self):
+            return None
+
+    def _slow_fetch():
+        nonlocal fetch_count
+        with lock:
+            fetch_count += 1
+            label = "first" if fetch_count == 1 else "second"
+            labels_by_thread[threading.get_ident()] = label
+        if label == "first":
+            first_fetch_entered.set()
+            release_first_fetch.wait(timeout=2.0)
+        else:
+            second_fetch_entered.set()
+            release_second_fetch.wait(timeout=2.0)
+
+    with patch("lark_channel.channel.channel.WSClient", _LabelledWS), patch.object(
+        c, "_fetch_bot_identity_sync", side_effect=_slow_fetch
+    ):
+        def run_start():
+            try:
+                c.start()
+            except Exception as exc:
+                errors.append(exc)
+
+        first = threading.Thread(target=run_start)
+        first.start()
+        assert first_fetch_entered.wait(1.0)
+
+        c.stop()
+
+        second = threading.Thread(target=run_start)
+        second.start()
+        assert second_fetch_entered.wait(1.0)
+
+        release_first_fetch.set()
+        first.join(timeout=2.0)
+        release_second_fetch.set()
+        second.join(timeout=2.0)
+
+    assert not first.is_alive()
+    assert not second.is_alive()
+    assert errors == []
+    assert "first" not in started_labels
+    assert "second" in started_labels
+
+
+def test_bot_identity_accessor_before_resolve():
+    c = _client()
+    assert c.bot_identity is None
+
+
+def test_resolve_bot_identity_persists_to_safety_pipeline(monkeypatch):
+    """When identity resolves, it should propagate into the safety PolicyGate."""
+    async def fake_fetch(config):
+        return BotIdentity(open_id="ou_bot_xyz", name="Test Bot")
+
+    c = _client()
+    c._ensure_bg_loop()
+    monkeypatch.setattr("lark_channel.channel.channel.fetch_bot_identity", fake_fetch)
+    fut = asyncio.run_coroutine_threadsafe(c.resolve_bot_identity(), c._bg_loop)
+    identity = fut.result(timeout=2)
+    assert identity.open_id == "ou_bot_xyz"
+    assert c._bot_open_id == "ou_bot_xyz"
+    # Safety gate's bot open id should also be set
+    assert c._safety._policy._bot_open_id == "ou_bot_xyz"  # type: ignore[attr-defined]
+
+
+def test_build_dispatcher_registers_required_events():
+    """Dispatcher should have processors for all 5 event types we handle."""
+    c = _client()
+    c._ensure_bg_loop()
+    dispatcher = c._build_dispatcher()
+    keys = set(dispatcher._processorMap.keys())
+    keys |= set(dispatcher._callback_processor_map.keys())
+    expected = {
+        "p2.im.message.receive_v1",
+        "p2.card.action.trigger",
+        "p2.im.message.reaction.created_v1",
+        "p2.im.message.reaction.deleted_v1",
+        "p2.im.chat.member.bot.added_v1",
+        "p2.im.chat.member.bot.deleted_v1",
+        "p2.im.message.message_read_v1",
+        # drive comment-add has no typed SDK processor and the wire
+        # payload may arrive under either schema (p1 callback envelope vs
+        # p2 WS envelope). Register both so neither path logs
+        # ``processor not found``.
+        "p1.drive.notice.comment_add_v1",
+        "p2.drive.notice.comment_add_v1",
+    }
+    missing = expected - keys
+    assert not missing, f"dispatcher missing processors: {missing}"
+
+
+def test_emit_reject_with_no_handler_only_logs(caplog):
+    import logging
+
+    from lark_channel.channel.safety import RejectEvent
+
+    c = _client()
+    with caplog.at_level(logging.DEBUG, logger="lark_channel"):
+        c._emit_reject(RejectEvent(
+            message_id="om_x", chat_id="oc_x", sender_id="ou_s", reason="policy_no_mention",
+        ))
+    # With no handler registered, _emit_reject must not raise. It may or may
+    # not log anything depending on level, but it must at least not surface
+    # through an uncaught exception.
+    # (Previously this assertion ended with ``... or True`` which made it
+    # vacuously pass; the intent was "tolerate missing log line while still
+    # asserting no exception", which the ``with caplog.at_level`` + absence
+    # of pytest raise already covers.)
+
+
+def test_emit_reject_dispatches_to_registered_handler():
+    from lark_channel.channel.safety import RejectEvent
+
+    c = _client()
+    got = []
+    c.on("reject", lambda e: got.append(e))
+    c._emit_reject(RejectEvent(
+        message_id="om_x", chat_id="oc_x", sender_id="ou_s", reason="policy_dm_disabled",
+    ))
+    assert len(got) == 1
+    assert got[0].reason == "policy_dm_disabled"
diff --git a/lark_channel/channel/tests/test_comment_event.py b/lark_channel/channel/tests/test_comment_event.py
new file mode 100644
index 0000000..da40ff2
--- /dev/null
+++ b/lark_channel/channel/tests/test_comment_event.py
@@ -0,0 +1,218 @@
+"""Tests for normalize_comment and dispatcher wiring.
+
+Two regressions are guarded here:
+
+1. The channel registers ``drive.notice.comment_add_v1`` under both ``p1`` and
+   ``p2`` schemas. The WS frontier wraps in a p2 envelope; legacy callbacks
+   use p1.
+
+2. After registration, the live comment payload still surfaced operator
+   open_id / mentioned_bot / timestamp as null — the original
+   ``normalize_comment`` was guessing at field names that don't exist in
+   the wire format. Real shape (observed end-to-end against a Feishu
+   tenant 2026-04-27): operator at ``notice_meta.from_user_id``,
+   mentioned-bot is the boolean ``is_mentioned``, timestamp is
+   ``create_time`` as a millisecond string.
+"""
+
+import threading
+
+from lark_channel.channel import FeishuChannel
+from lark_channel.channel.normalize.comment import CommentEvent, normalize_comment
+
+
+# ---------------------------------------------------------------------------
+# normalize_comment — real wire format
+# ---------------------------------------------------------------------------
+
+
+def test_full_payload_real_wire_format():
+    """Mirror a realistic ``drive.notice.comment_add_v1`` WS payload."""
+    payload = {
+        "event": {
+            "file_token": "doc_token_x",
+            "file_type": "docx",
+            "comment_id": "cmt_1",
+            "reply_id": "rpl_1",
+            "is_mentioned": True,
+            "create_time": "1700000000000",
+            "notice_meta": {
+                "from_user_id": {
+                    "open_id": "ou_op",
+                    "user_id": "u_op",
+                    "union_id": "on_op",
+                },
+                "to_user_id": {"open_id": "ou_bot"},
+                "file_token": "doc_token_x",
+                "file_type": "docx",
+                "is_mentioned": True,
+                "timestamp": "1700000000000",
+                "notice_type": "comment_add",
+            },
+        }
+    }
+    c = normalize_comment(payload)
+    assert isinstance(c, CommentEvent)
+    assert c.file_token == "doc_token_x"
+    assert c.file_type == "docx"
+    assert c.comment_id == "cmt_1"
+    assert c.reply_id == "rpl_1"
+    assert c.operator.open_id == "ou_op"
+    assert c.operator.user_id == "u_op"
+    assert c.operator.union_id == "on_op"
+    assert c.mentioned_bot is True
+    assert c.timestamp == 1700000000000
+
+
+def test_missing_file_token_returns_none():
+    payload = {"event": {"comment_id": "x"}}
+    assert normalize_comment(payload) is None
+
+
+def test_missing_operator_returns_none():
+    """Half-populated payloads (no operator) are dropped instead of
+    delivered with operator.open_id == None."""
+    payload = {
+        "event": {
+            "file_token": "t",
+            "file_type": "docx",
+            "comment_id": "c",
+            "create_time": "1",
+            # notice_meta missing → no operator → drop
+        }
+    }
+    assert normalize_comment(payload) is None
+
+
+def test_envelope_timestamp_used_when_inner_event_omits_it():
+    """The real WS payload puts ``create_time`` on the p2 envelope's
+    ``header``, not the inner event dict. Without this fallback, every
+    delivered ``CommentEvent`` would have ``timestamp=0``."""
+    payload = {
+        "event": {
+            "file_token": "doc_token_x",
+            "file_type": "docx",
+            "comment_id": "cmt_no_inner_ts",
+            "is_mentioned": True,
+            "notice_meta": {"from_user_id": {"open_id": "ou_op"}},
+            # NB: no create_time / action_time / timestamp anywhere inside
+        }
+    }
+    c = normalize_comment(payload, envelope_timestamp="1700000000000")
+    assert c is not None
+    assert c.timestamp == 1700000000000
+
+
+def test_legacy_top_level_user_id_fallback():
+    """Older p1 callbacks ship the operator at top level as ``user_id``
+    instead of ``notice_meta.from_user_id``. Don't break those."""
+    payload = {
+        "event": {
+            "file_token": "t1",
+            "file_type": "sheet",
+            "comment_id": "cmt_abc",
+            "user_id": {"open_id": "ou_legacy", "union_id": "on_legacy"},
+            "is_mention": True,
+            "action_time": "1650000000000",
+        }
+    }
+    c = normalize_comment(payload)
+    assert c is not None
+    assert c.operator.open_id == "ou_legacy"
+    assert c.operator.union_id == "on_legacy"
+    assert c.mentioned_bot is True
+    assert c.timestamp == 1650000000000
+
+
+def test_is_mentioned_false_propagates():
+    """When the bot was NOT @-mentioned (e.g. an at-document comment), the
+    flag must surface as False. The result must not depend on a mentions array
+    that doesn't exist on the wire."""
+    payload = {
+        "event": {
+            "file_token": "t",
+            "file_type": "docx",
+            "comment_id": "c",
+            "is_mentioned": False,
+            "create_time": "1",
+            "notice_meta": {"from_user_id": {"open_id": "ou_op"}},
+        }
+    }
+    c = normalize_comment(payload)
+    assert c is not None and c.mentioned_bot is False
+
+
+# ---------------------------------------------------------------------------
+# Dispatcher wiring — both p1 and p2 must be registered
+# ---------------------------------------------------------------------------
+
+
+def _client() -> FeishuChannel:
+    return FeishuChannel(app_id="cli_test", app_secret="secret_test")
+
+
+def test_dispatcher_registers_both_schemas_for_comment_add():
+    c = _client()
+    c._ensure_bg_loop()
+    dispatcher = c._build_dispatcher()
+    keys = set(dispatcher._processorMap.keys())
+    # WS frontier wraps even legacy events in a p2 envelope; the legacy
+    # HTTP callback uses p1. Without both, half the deployments log
+    # ``processor not found``.
+    assert "p1.drive.notice.comment_add_v1" in keys, (
+        f"missing p1 processor; got {sorted(keys)}"
+    )
+    assert "p2.drive.notice.comment_add_v1" in keys, (
+        f"missing p2 processor; got {sorted(keys)}"
+    )
+
+
+def test_incoming_comment_event_invokes_comment_handler():
+    """End-to-end: feed a CustomizedEvent (real wire format) into the
+    dispatcher processor and assert ``on("comment", ...)`` fires with a
+    fully-populated ``CommentEvent``."""
+    from lark_channel.event.custom import CustomizedEvent
+
+    c = _client()
+    c._ensure_bg_loop()
+    dispatcher = c._build_dispatcher()
+
+    got: list[CommentEvent] = []
+    done = threading.Event()
+
+    def _on_comment(ev: CommentEvent) -> None:
+        got.append(ev)
+        done.set()
+
+    c.on("comment", _on_comment)
+
+    ctx = CustomizedEvent()
+    ctx.event = {
+        "file_token": "doc_token_case",
+        "file_type": "docx",
+        "comment_id": "cmt_42",
+        "reply_id": "rpl_42",
+        "is_mentioned": True,
+        "create_time": "1712000000000",
+        "notice_meta": {
+            "from_user_id": {
+                "open_id": "ou_op_user",
+                "user_id": "u_op",
+            },
+            "is_mentioned": True,
+            "timestamp": "1712000000000",
+        },
+    }
+
+    # Use the p2 processor (modern WS path) — the regression chain.
+    processor = dispatcher._processorMap["p2.drive.notice.comment_add_v1"]
+    processor.do(ctx)
+    assert done.wait(timeout=2.0), "comment handler was not invoked within 2s"
+    assert len(got) == 1
+    ev = got[0]
+    assert ev.file_token == "doc_token_case"
+    assert ev.comment_id == "cmt_42"
+    assert ev.operator.open_id == "ou_op_user"
+    assert ev.operator.user_id == "u_op"
+    assert ev.mentioned_bot is True
+    assert ev.timestamp == 1712000000000
diff --git a/lark_channel/channel/tests/test_config.py b/lark_channel/channel/tests/test_config.py
new file mode 100644
index 0000000..1790897
--- /dev/null
+++ b/lark_channel/channel/tests/test_config.py
@@ -0,0 +1,138 @@
+"""Coverage for the config dataclasses — default values + nesting."""
+
+from lark_channel.channel.config import (
+    ChannelConfig,
+    DedupConfig,
+    FooterConfig,
+    GroupOverride,
+    InboundConfig,
+    MarkdownConverter,
+    MediaCapabilities,
+    NameCacheConfig,
+    OutboundConfig,
+    PerChatReplyMode,
+    PolicyConfig,
+    RetryConfig,
+    SafetyConfig,
+    StreamThrottleConfig,
+    TransportConfig,
+    UATConfig,
+)
+
+
+def test_media_capabilities_default_all_true():
+    mc = MediaCapabilities()
+    assert mc.image and mc.audio and mc.video and mc.file and mc.sticker
+
+
+def test_name_cache_defaults_match_spec():
+    c = NameCacheConfig()
+    assert c.enabled and c.max_size == 2000 and c.ttl_seconds == 24 * 3600
+
+
+def test_inbound_config_defaults():
+    ib = InboundConfig()
+    assert ib.expand_merge_forward is True
+    assert ib.fetch_interactive_card is True
+    assert ib.reaction_notifications == "own"
+    assert ib.merge_forward_max_depth == 3
+    assert ib.merge_forward_max_items == 50
+
+
+def test_outbound_config_defaults():
+    ob = OutboundConfig()
+    assert ob.reply_mode == "auto"
+    assert ob.text_chunk_limit == 3500  # node-aligned (DEFAULT_CHUNK_LIMIT)
+    assert ob.chunk_mode == "newline"
+    assert ob.markdown_converter.enabled is True
+    assert ob.markdown_converter.table_mode == "off"
+    assert ob.ssrf_allowlist is None
+    assert isinstance(ob.retry, RetryConfig)
+    assert ob.retry.max_attempts == 3
+
+
+def test_stream_throttle_defaults():
+    t = StreamThrottleConfig()
+    assert t.min_chars == 20 and t.max_chars == 200 and t.idle_ms == 300
+
+
+def test_footer_config_all_off_by_default():
+    f = FooterConfig()
+    assert not any([f.status, f.elapsed, f.tokens, f.model, f.cache, f.context])
+
+
+def test_dedup_config_defaults():
+    d = DedupConfig()
+    assert d.enabled is True
+    assert d.ttl_seconds == 12 * 3600
+    assert d.max_entries == 5000
+    assert d.sweep_seconds == 5 * 60
+
+
+def test_uat_config_defaults():
+    u = UATConfig()
+    assert u.refresh_before_expiry_seconds == 300
+    assert u.device_poll_interval_seconds == 5
+    assert u.allowed_scopes is None
+    assert u.blocked_scopes is None
+
+
+def test_transport_config_default_ws():
+    t = TransportConfig()
+    assert t.kind == "ws"
+    assert t.auto_reconnect is True
+
+
+def test_policy_config_defaults():
+    p = PolicyConfig()
+    assert p.dm_policy == "open"
+    assert p.group_policy == "open"
+    assert p.require_mention is True
+    assert p.respond_to_mention_all is False
+    assert p.allow_from is None
+    assert p.group_overrides == {}
+
+
+def test_group_override_all_fields_optional():
+    o = GroupOverride()
+    assert o.policy is None and o.enabled is None
+
+
+def test_safety_config_nests_dedup_and_batch():
+    s = SafetyConfig()
+    assert isinstance(s.dedup, DedupConfig)
+    # text_batch / chat_queue live in safety.types; we just verify the
+    # nesting is present without pinning their class names here.
+    assert s.text_batch is not None
+    assert s.chat_queue is not None
+    assert s.stale_message_window_ms == 30 * 60 * 1000
+
+
+def test_channel_config_top_level_areas():
+    c = ChannelConfig()
+    assert c.app_id == "" and c.app_secret == ""
+    assert c.encrypt_key is None and c.verification_token is None
+    assert isinstance(c.transport, TransportConfig)
+    assert isinstance(c.policy, PolicyConfig)
+    assert isinstance(c.safety, SafetyConfig)
+    assert isinstance(c.inbound, InboundConfig)
+    assert isinstance(c.outbound, OutboundConfig)
+    assert isinstance(c.uat, UATConfig)
+
+
+def test_per_chat_reply_mode_defaults():
+    m = PerChatReplyMode()
+    assert m.default == "auto"
+    assert m.dm is None and m.group is None
+
+
+def test_markdown_converter_table_mode_override():
+    mc = MarkdownConverter(enabled=False, table_mode="bullets")
+    assert mc.enabled is False
+    assert mc.table_mode == "bullets"
+
+
+def test_retry_config_defaults():
+    r = RetryConfig()
+    assert r.max_attempts == 3
+    assert r.base_delay_ms == 500
diff --git a/lark_channel/channel/tests/test_converter_node_aligned_output.py b/lark_channel/channel/tests/test_converter_node_aligned_output.py
new file mode 100644
index 0000000..a98833b
--- /dev/null
+++ b/lark_channel/channel/tests/test_converter_node_aligned_output.py
@@ -0,0 +1,408 @@
+"""Byte-level output alignment with node-sdk converters.
+
+Every assertion here corresponds to a node-sdk converter's observable output
+format (tag names, indentation, emoji prefixes, attribute names). Divergence
+caught here = a regression that node users would see differently from
+Python users.
+
+Node source reference (commit ccc7e31):
+    https://github.com/larksuite/node-sdk/tree/ccc7e31/channel/normalize/converters
+"""
+
+from pathlib import Path
+
+from lark_channel.channel.normalize.converters import (
+    calendar as calendar_c,
+    folder as folder_c,
+    merge_forward as mf_c,
+    share as share_c,
+    system as system_c,
+    todo as todo_c,
+    video_chat as vc_c,
+    vote as vote_c,
+)
+from lark_channel.channel.types import (
+    CalendarContent,
+    FolderContent,
+    GeneralCalendarContent,
+    ImageContent,
+    MergeForwardContent,
+    MergeForwardItem,
+    ShareCalendarEventContent,
+    ShareChatContent,
+    ShareUserContent,
+    SystemContent,
+    TextContent,
+    TodoContent,
+    VideoChatContent,
+    VoteContent,
+)
+
+
+# ---- system: template regex expansion ---------------------------------------
+
+
+def test_system_expands_template_variables():
+    content = SystemContent(
+        template="{from_user} invited {to_chatters}",
+        raw={
+            "template": "{from_user} invited {to_chatters}",
+            "from_user": [{"name": "Alice"}],
+            "to_chatters": [{"name": "Bob"}, {"name": "Carol"}],
+        },
+    )
+    text, _ = system_c.convert(content)
+    assert text == "Alice invited Bob, Carol"
+
+
+def test_system_missing_template_emits_placeholder():
+    text, _ = system_c.convert(SystemContent(template=""))
+    assert text == "[system message]"
+
+
+def test_system_unknown_key_becomes_empty():
+    # Node's policy: unknown key → empty string (matches `val == null` branch
+    # in node's system.ts). Trailing whitespace is trimmed.
+    content = SystemContent(template="Hi {unknown}", raw={"template": "Hi {unknown}"})
+    text, _ = system_c.convert(content)
+    assert text == "Hi"
+
+
+def test_system_non_string_value_preserves_placeholder():
+    # Node's policy: if value is neither string/array/null, leave the
+    # placeholder as-is (fallthrough `return match`).
+    content = SystemContent(
+        template="Count: {n}",
+        raw={"template": "Count: {n}", "n": 42},  # int, not str
+    )
+    text, _ = system_c.convert(content)
+    assert text == "Count: {n}"
+
+
+# ---- todo: rich multi-line output -------------------------------------------
+
+
+def test_todo_with_title_body_due_formats_multiline():
+    content = TodoContent(title="Ship it", body="before EOD", due_time=1700000000000)
+    text, _ = todo_c.convert(content)
+    assert text.startswith("<todo>\n")
+    assert text.endswith("\n</todo>")
+    assert "Ship it" in text
+    assert "before EOD" in text
+    assert "Due: " in text
+
+
+def test_todo_empty_emits_placeholder():
+    text, _ = todo_c.convert(TodoContent())
+    assert text == "<todo>\n[todo]\n</todo>"
+
+
+# ---- video_chat: <meeting> block with emoji + time --------------------------
+
+
+def test_video_chat_renders_meeting_block():
+    content = VideoChatContent(topic="Sprint Planning", start_time=1700000000000)
+    text, _ = vc_c.convert(content)
+    assert text.startswith("<meeting>\n")
+    assert text.endswith("\n</meeting>")
+    assert "📹 Sprint Planning" in text
+    assert "🕙 " in text
+
+
+def test_video_chat_empty_emits_placeholder():
+    text, _ = vc_c.convert(VideoChatContent())
+    assert text == "<meeting>\n[video chat]\n</meeting>"
+
+
+# ---- calendar (3 variants): rich block + correct tag names ------------------
+
+
+def test_calendar_invite_tag_name():
+    content = CalendarContent(summary="Sync", start_time=1700000000000)
+    text, _ = calendar_c.convert(content)
+    assert text.startswith("<calendar_invite>\n")
+    assert text.endswith("\n</calendar_invite>")
+    assert "📅 Sync" in text
+
+
+def test_general_calendar_tag_name_is_calendar():
+    content = GeneralCalendarContent(summary="Demo")
+    text, _ = calendar_c.convert_general(content)
+    assert text.startswith("<calendar>\n")
+    assert text.endswith("\n</calendar>")
+    assert "📅 Demo" in text
+
+
+def test_share_calendar_event_tag_name_is_calendar_share():
+    content = ShareCalendarEventContent(summary="Demo")
+    text, _ = calendar_c.convert_share_event(content)
+    assert text.startswith("<calendar_share>\n")
+    assert text.endswith("\n</calendar_share>")
+
+
+def test_calendar_start_end_rendered_with_tilde():
+    content = CalendarContent(
+        summary="Mtg", start_time=1700000000000, end_time=1700003600000
+    )
+    text, _ = calendar_c.convert(content)
+    assert "~" in text
+
+
+# ---- vote: multi-line bullets -----------------------------------------------
+
+
+def test_vote_multiline_with_bullet_options():
+    content = VoteContent(topic="Lunch?", options=["Pizza", "Sushi"])
+    text, _ = vote_c.convert(content)
+    lines = text.split("\n")
+    assert lines[0] == "<vote>"
+    assert "Lunch?" in lines
+    assert "• Pizza" in lines
+    assert "• Sushi" in lines
+    assert lines[-1] == "</vote>"
+
+
+def test_vote_empty_placeholder():
+    text, _ = vote_c.convert(VoteContent())
+    assert text == "<vote>\n[vote]\n</vote>"
+
+
+# ---- share: id= attribute (not chat_id= / user_id=) -------------------------
+
+
+def test_share_chat_uses_id_attribute():
+    text, _ = share_c.convert_chat(ShareChatContent(chat_id="oc_123"))
+    assert text == '<group_card id="oc_123"/>'
+
+
+def test_share_user_uses_id_attribute():
+    text, _ = share_c.convert_user(ShareUserContent(user_id="ou_456"))
+    assert text == '<contact_card id="ou_456"/>'
+
+
+# ---- folder: key= attribute + optional name= ------------------------------
+
+
+def test_folder_with_key_and_name():
+    text, _ = folder_c.convert(FolderContent(file_key="fk_1", file_name="docs"))
+    assert text == '<folder key="fk_1" name="docs"/>'
+
+
+def test_folder_with_key_only():
+    text, _ = folder_c.convert(FolderContent(file_key="fk_1"))
+    assert text == '<folder key="fk_1"/>'
+
+
+def test_folder_no_key_falls_back_to_placeholder():
+    text, _ = folder_c.convert(FolderContent(file_name="docs"))
+    assert text == "[folder]"
+
+
+# ---- merge_forward: header not indented, body indented 4 spaces -------------
+
+
+def test_merge_forward_item_header_is_flush_left():
+    child = MergeForwardItem(
+        message_id="om_1",
+        sender_name="Alice",
+        create_time=1700000000000,
+        content=TextContent(text="hello"),
+    )
+    mf = MergeForwardContent(items=[child])
+    text, _ = mf_c.convert(mf)
+    lines = text.split("\n")
+    # Header line: "[timestamp] Alice:" — no leading spaces
+    header_line = next(line for line in lines if "Alice:" in line)
+    assert not header_line.startswith(" "), f"header should be flush-left: {header_line!r}"
+    # Body line: "    hello" — 4 spaces
+    body_line = next(line for line in lines if "hello" in line)
+    assert body_line == "    hello", f"body should be indented 4 spaces: {body_line!r}"
+
+
+def test_merge_forward_empty_or_loading_is_self_closing():
+    assert mf_c.convert(MergeForwardContent(loading=True))[0] == "<forwarded_messages/>"
+    assert mf_c.convert(MergeForwardContent(items=[]))[0] == "<forwarded_messages/>"
+
+
+def test_merge_forward_nested_indents_by_4_more():
+    inner_child = MergeForwardItem(
+        message_id="om_inner",
+        sender_name="Bob",
+        create_time=1700000000000,
+        content=TextContent(text="inner text"),
+    )
+    inner = MergeForwardContent(items=[inner_child])
+    outer_child = MergeForwardItem(
+        message_id="om_outer",
+        sender_name="Alice",
+        create_time=1700000000000,
+        content=inner,
+    )
+    outer = MergeForwardContent(items=[outer_child])
+    text, _ = mf_c.convert(outer)
+    # The inner "inner text" line should be indented 8 spaces (4 from outer
+    # body indent + 4 from inner body indent).
+    inner_line = next(line for line in text.split("\n") if "inner text" in line)
+    assert inner_line == "        inner text", f"nested body needs 8-space indent: {inner_line!r}"
+
+
+def test_merge_forward_truncation_footer():
+    child = MergeForwardItem(
+        message_id="om_1",
+        sender_name="Alice",
+        create_time=1700000000000,
+        content=TextContent(text="hi"),
+    )
+    mf = MergeForwardContent(items=[child], truncated=True)
+    text, _ = mf_c.convert(mf)
+    assert "... (truncated)" in text
+    # Truncation marker should NOT be indented (node emits `\n... (truncated)`).
+    assert "\n... (truncated)" in text
+
+
+def test_merge_forward_missing_create_time_falls_back_to_unknown():
+    child = MergeForwardItem(
+        message_id="om_1",
+        sender_name="Alice",
+        create_time=None,
+        content=TextContent(text="hi"),
+    )
+    mf = MergeForwardContent(items=[child])
+    text, _ = mf_c.convert(mf)
+    # Matches node's `timestamp = createMs > 0 ? format(...) : 'unknown'`.
+    assert "[unknown] Alice:" in text
+
+
+def test_merge_forward_item_that_raises_is_skipped():
+    class _Boom:
+        def __getattribute__(self, name):
+            raise RuntimeError("simulated failure")
+
+    ok_child = MergeForwardItem(
+        message_id="om_1",
+        sender_name="Alice",
+        create_time=1700000000000,
+        content=TextContent(text="good"),
+    )
+    mf = MergeForwardContent(items=[_Boom(), ok_child])
+    text, _ = mf_c.convert(mf)
+    # The good item survives; the broken one is silently dropped.
+    assert "Alice:" in text
+    assert "good" in text
+
+
+def test_merge_forward_nested_resources_keep_depth_first_order():
+    first = MergeForwardContent(
+        items=[
+            MergeForwardItem(
+                message_id="om_first_image",
+                sender_name="Alice",
+                create_time=1700000000000,
+                content=ImageContent(image_key="img_first"),
+            )
+        ]
+    )
+    second = MergeForwardContent(
+        items=[
+            MergeForwardItem(
+                message_id="om_second_image",
+                sender_name="Bob",
+                create_time=1700000000000,
+                content=ImageContent(image_key="img_second"),
+            )
+        ]
+    )
+    mf = MergeForwardContent(
+        items=[
+            MergeForwardItem(
+                message_id="om_first_forward",
+                sender_name="Alice",
+                create_time=1700000000000,
+                content=first,
+            ),
+            MergeForwardItem(
+                message_id="om_second_forward",
+                sender_name="Bob",
+                create_time=1700000000000,
+                content=second,
+            ),
+        ]
+    )
+
+    _, resources = mf_c.convert(mf)
+
+    assert [resource.file_key for resource in resources] == [
+        "img_first",
+        "img_second",
+    ]
+
+
+def test_merge_forward_converter_avoids_pep585_runtime_annotations_for_python38():
+    source = Path(mf_c.__file__).read_text(encoding="utf-8")
+
+    assert "dict[" not in source
+    assert "set[" not in source
+
+
+# ---- Calendar edge cases -----------------------------------------------
+
+
+def test_calendar_only_summary_no_time():
+    text, _ = calendar_c.convert(CalendarContent(summary="Just a note"))
+    assert "📅 Just a note" in text
+    assert "🕙" not in text  # no time line when start/end absent
+
+
+def test_calendar_only_start_no_end():
+    text, _ = calendar_c.convert(CalendarContent(summary="S", start_time=1700000000000))
+    assert "🕙 " in text
+    assert "~" not in text  # no range separator when end missing
+
+
+def test_calendar_empty_falls_back_to_placeholder():
+    text, _ = calendar_c.convert(CalendarContent())
+    assert text == "<calendar_invite>\n[calendar event]\n</calendar_invite>"
+
+
+# ---- Vote edge cases ---------------------------------------------------
+
+
+def test_vote_options_only_no_topic():
+    text, _ = vote_c.convert(VoteContent(options=["A", "B"]))
+    lines = text.split("\n")
+    assert lines[0] == "<vote>"
+    assert "• A" in lines and "• B" in lines
+    assert lines[-1] == "</vote>"
+
+
+# ---- Todo edge cases ---------------------------------------------------
+
+
+def test_todo_only_due_time():
+    text, _ = todo_c.convert(TodoContent(due_time=1700000000000))
+    assert "Due: " in text
+
+
+def test_todo_only_title():
+    text, _ = todo_c.convert(TodoContent(title="finish audit"))
+    assert "finish audit" in text
+    assert "Due:" not in text
+
+
+# ---- Share fallback for empty id --------------------------------------
+
+
+def test_share_chat_with_empty_chat_id():
+    # Node emits id="" for missing chat_id (``?? ''`` coalesce).
+    text, _ = share_c.convert_chat(ShareChatContent(chat_id=""))
+    assert text == '<group_card id=""/>'
+
+
+# ---- System fallback --------------------------------------------------
+
+
+def test_system_empty_raw_uses_template_as_is():
+    # Template with no raw → variables can't resolve but template remains.
+    content = SystemContent(template="Hello World")
+    text, _ = system_c.convert(content)
+    assert text == "Hello World"
diff --git a/lark_channel/channel/tests/test_dedup.py b/lark_channel/channel/tests/test_dedup.py
new file mode 100644
index 0000000..efa15a6
--- /dev/null
+++ b/lark_channel/channel/tests/test_dedup.py
@@ -0,0 +1,61 @@
+"""Tests for dedup storage + two-key strategy."""
+
+from lark_channel.channel.normalize.dedup import Deduper, InMemoryDedupStore, make_event_key, make_message_key
+
+
+def test_basic_mark_and_seen():
+    s = InMemoryDedupStore()
+    assert s.seen("k") is False
+    s.mark("k", ttl_seconds=60)
+    assert s.seen("k") is True
+
+
+def test_ttl_expires():
+    s = InMemoryDedupStore()
+    s.mark("k", ttl_seconds=0)
+    # ttl=0 is effectively expired immediately
+    assert s.seen("k") is False
+
+
+def test_lru_bounded():
+    s = InMemoryDedupStore(max_entries=3)
+    s.mark("a", 60)
+    s.mark("b", 60)
+    s.mark("c", 60)
+    s.mark("d", 60)
+    # 'a' must have been evicted
+    assert s.seen("a") is False
+    assert s.seen("d") is True
+
+
+def test_two_key_dedupes_by_event_id_first():
+    s = InMemoryDedupStore()
+    d = Deduper(s, ttl_seconds=60)
+    assert d.check_and_mark("app", "e1", "m1") is True
+    assert d.check_and_mark("app", "e1", "m2") is False  # event_id dup
+
+
+def test_two_key_dedupes_by_message_id():
+    s = InMemoryDedupStore()
+    d = Deduper(s, ttl_seconds=60)
+    assert d.check_and_mark("app", "e1", "m1") is True
+    assert d.check_and_mark("app", "e2", "m1") is False  # message_id dup
+
+
+def test_different_accounts_do_not_collide():
+    s = InMemoryDedupStore()
+    d = Deduper(s, ttl_seconds=60)
+    assert d.check_and_mark("app1", "e1", "m1") is True
+    assert d.check_and_mark("app2", "e1", "m1") is True
+
+
+def test_dedup_disabled_always_passes():
+    s = InMemoryDedupStore()
+    d = Deduper(s, ttl_seconds=60, enabled=False)
+    assert d.check_and_mark("app", "e1", "m1") is True
+    assert d.check_and_mark("app", "e1", "m1") is True
+
+
+def test_key_builders():
+    assert make_event_key("a", "e") == "evt:a:e"
+    assert make_message_key("a", "m") == "msg:a:m"
diff --git a/lark_channel/channel/tests/test_device_flow.py b/lark_channel/channel/tests/test_device_flow.py
new file mode 100644
index 0000000..30ea39c
--- /dev/null
+++ b/lark_channel/channel/tests/test_device_flow.py
@@ -0,0 +1,113 @@
+"""DeviceFlowClient tests with a mocked httpx transport."""
+
+from typing import Any, Dict, List
+
+import httpx
+import pytest
+
+from lark_channel.channel.auth.device_flow import DeviceFlowClient, uat_needs_refresh
+from lark_channel.channel.errors import UATAuthError
+from lark_channel.channel.types import UAT
+
+
+def _mock_transport(responses: List[Dict[str, Any]]):
+    """Build an httpx MockTransport that returns the next response on each call."""
+    idx = [0]
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        if idx[0] >= len(responses):
+            return httpx.Response(500, json={"msg": "no more canned responses"})
+        r = responses[idx[0]]
+        idx[0] += 1
+        return httpx.Response(200, json=r)
+
+    return httpx.MockTransport(handler)
+
+
+@pytest.mark.asyncio
+async def test_start_returns_device_init():
+    transport = _mock_transport(
+        [
+            {
+                "verification_uri": "https://x/auth",
+                "verification_uri_complete": "https://x/auth?user_code=ABCD",
+                "user_code": "ABCD",
+                "device_code": "dc_1",
+                "expires_in": 600,
+                "interval": 5,
+            }
+        ]
+    )
+    client = httpx.AsyncClient(transport=transport)
+    df = DeviceFlowClient("cli", "sec", http_client=client)
+    init = await df.start(["im:message"])
+    assert init.device_code == "dc_1"
+    assert init.user_code == "ABCD"
+    assert init.interval == 5
+    assert "user_code=ABCD" in init.verification_uri_complete
+
+
+@pytest.mark.asyncio
+async def test_poll_returns_uat_on_success():
+    transport = _mock_transport(
+        [
+            {
+                "access_token": "tok_x",
+                "refresh_token": "rtok",
+                "expires_in": 7200,
+                "refresh_token_expires_in": 2592000,
+                "scope": "im:message",
+            }
+        ]
+    )
+    client = httpx.AsyncClient(transport=transport)
+    df = DeviceFlowClient("cli", "sec", http_client=client)
+    uat = await df.poll("dc_1", interval=1, timeout_seconds=10)
+    assert uat.access_token == "tok_x"
+    assert uat.refresh_token == "rtok"
+    assert "im:message" in uat.scopes
+
+
+@pytest.mark.asyncio
+async def test_poll_access_denied_raises():
+    transport = _mock_transport([{"error": "access_denied", "msg": "user denied"}])
+    client = httpx.AsyncClient(transport=transport)
+    df = DeviceFlowClient("cli", "sec", http_client=client)
+    with pytest.raises(UATAuthError):
+        await df.poll("dc_1", interval=1, timeout_seconds=3)
+
+
+@pytest.mark.asyncio
+async def test_poll_pending_then_ok():
+    # First response: authorization_pending; second: success.
+    transport = _mock_transport(
+        [
+            {"error": "authorization_pending"},
+            {"access_token": "t", "expires_in": 300, "scope": "im:message"},
+        ]
+    )
+    client = httpx.AsyncClient(transport=transport)
+    df = DeviceFlowClient("cli", "sec", http_client=client)
+    uat = await df.poll("dc_1", interval=0, timeout_seconds=10)
+    assert uat.access_token == "t"
+
+
+def test_uat_needs_refresh_threshold():
+    import time
+
+    soon = UAT(access_token="t", expires_at=time.time() + 60)
+    later = UAT(access_token="t", expires_at=time.time() + 1800)
+    assert uat_needs_refresh(soon, slack_seconds=300) is True
+    assert uat_needs_refresh(later, slack_seconds=300) is False
+
+
+@pytest.mark.asyncio
+async def test_refresh_uses_refresh_token():
+    transport = _mock_transport(
+        [{"access_token": "fresh", "refresh_token": "r2", "expires_in": 600, "scope": "im:message"}]
+    )
+    client = httpx.AsyncClient(transport=transport)
+    df = DeviceFlowClient("cli", "sec", http_client=client)
+    uat = await df.refresh("r1")
+    assert uat.access_token == "fresh"
+    assert uat.refresh_token == "r2"
diff --git a/lark_channel/channel/tests/test_download_to_file.py b/lark_channel/channel/tests/test_download_to_file.py
new file mode 100644
index 0000000..5b06e58
--- /dev/null
+++ b/lark_channel/channel/tests/test_download_to_file.py
@@ -0,0 +1,137 @@
+"""Tests for FeishuChannel.download_resource_to_file."""
+
+from unittest.mock import patch
+
+import pytest
+
+from lark_channel.channel import FeishuChannel, FeishuChannelError, FeishuChannelErrorCode
+
+
+@pytest.mark.asyncio
+async def test_success_returns_existing_path(tmp_path):
+    ch = FeishuChannel(app_id="cli_x", app_secret="x")
+
+    fake_bytes = b"\x89PNG\r\n\x1a\nrest"
+
+    async def fake_download(*args, **kwargs):
+        return fake_bytes, "image/png"
+
+    with patch(
+        "lark_channel.channel._api_helpers.download_media_with_meta",
+        side_effect=fake_download,
+    ):
+        path = await ch.download_resource_to_file(
+            file_key="img_xyz",
+            resource_type="image",
+            message_id="om_test",
+            dest_dir=tmp_path,
+        )
+
+    assert path.exists()
+    assert path.parent == tmp_path
+    assert path.read_bytes() == fake_bytes
+    # Suffix from content-type "image/png"
+    assert path.suffix == ".png"
+
+
+@pytest.mark.asyncio
+async def test_dest_dir_is_auto_mkdir(tmp_path):
+    ch = FeishuChannel(app_id="cli_x", app_secret="x")
+    target = tmp_path / "deep" / "nested" / "dir"
+    assert not target.exists()
+
+    async def fake_download(*args, **kwargs):
+        return b"data", "application/pdf"
+
+    with patch(
+        "lark_channel.channel._api_helpers.download_media_with_meta",
+        side_effect=fake_download,
+    ):
+        path = await ch.download_resource_to_file(
+            file_key="f1", resource_type="file", message_id="om_x", dest_dir=target
+        )
+    assert path.parent == target
+    assert path.suffix == ".pdf"
+
+
+@pytest.mark.asyncio
+async def test_failure_raises_download_failed(tmp_path):
+    ch = FeishuChannel(app_id="cli_x", app_secret="x")
+
+    async def fake_download(*args, **kwargs):
+        return None, None  # failure path
+
+    with patch(
+        "lark_channel.channel._api_helpers.download_media_with_meta",
+        side_effect=fake_download,
+    ):
+        with pytest.raises(FeishuChannelError) as excinfo:
+            await ch.download_resource_to_file(
+                file_key="bad", resource_type="image", message_id="om_x", dest_dir=tmp_path
+            )
+        assert excinfo.value.code == FeishuChannelErrorCode.DOWNLOAD_FAILED
+
+
+@pytest.mark.asyncio
+async def test_explicit_file_name_overrides_inferred(tmp_path):
+    ch = FeishuChannel(app_id="cli_x", app_secret="x")
+
+    async def fake_download(*args, **kwargs):
+        return b"data", "image/jpeg"
+
+    with patch(
+        "lark_channel.channel._api_helpers.download_media_with_meta",
+        side_effect=fake_download,
+    ):
+        path = await ch.download_resource_to_file(
+            file_key="k", resource_type="image", message_id="m",
+            dest_dir=tmp_path, file_name="custom.bin",
+        )
+    assert path.name == "custom.bin"
+
+
+@pytest.mark.asyncio
+async def test_explicit_file_name_cannot_escape_dest_dir(tmp_path):
+    ch = FeishuChannel(app_id="cli_x", app_secret="x")
+
+    async def fake_download(*args, **kwargs):
+        return b"data", "image/jpeg"
+
+    with patch(
+        "lark_channel.channel._api_helpers.download_media_with_meta",
+        side_effect=fake_download,
+    ):
+        with pytest.raises(FeishuChannelError) as excinfo:
+            await ch.download_resource_to_file(
+                file_key="k",
+                resource_type="image",
+                message_id="m",
+                dest_dir=tmp_path,
+                file_name="../escape.bin",
+            )
+
+    assert excinfo.value.code == FeishuChannelErrorCode.DOWNLOAD_FAILED
+    assert not (tmp_path.parent / "escape.bin").exists()
+
+
+@pytest.mark.asyncio
+async def test_default_file_name_cannot_escape_dest_dir(tmp_path):
+    ch = FeishuChannel(app_id="cli_x", app_secret="x")
+
+    async def fake_download(*args, **kwargs):
+        return b"data", "image/jpeg"
+
+    with patch(
+        "lark_channel.channel._api_helpers.download_media_with_meta",
+        side_effect=fake_download,
+    ):
+        with pytest.raises(FeishuChannelError) as excinfo:
+            await ch.download_resource_to_file(
+                file_key="../escape",
+                resource_type="image",
+                message_id="m",
+                dest_dir=tmp_path,
+            )
+
+    assert excinfo.value.code == FeishuChannelErrorCode.DOWNLOAD_FAILED
+    assert not (tmp_path.parent / "escape.jpg").exists()
diff --git a/lark_channel/channel/tests/test_driver.py b/lark_channel/channel/tests/test_driver.py
new file mode 100644
index 0000000..a69bdef
--- /dev/null
+++ b/lark_channel/channel/tests/test_driver.py
@@ -0,0 +1,130 @@
+"""Driver smoke tests: verify the adapter correctly constructs SDK requests.
+
+We don't hit the network — instead we patch the underlying Lark `Client`
+service methods to record the built Request objects, then assert the
+builders wired up fields as expected.
+"""
+
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from lark_channel.channel.driver import LarkClientDriver
+
+
+def _stub_client():
+    c = MagicMock()
+    # im.v1.message.*
+    msg = c.im.v1.message
+    msg.acreate = AsyncMock(return_value=MagicMock(code=0, msg="", data=MagicMock(message_id="om_1")))
+    msg.areply = AsyncMock(return_value=MagicMock(code=0, msg="", data=MagicMock(message_id="om_r")))
+    msg.aupdate = AsyncMock(return_value=MagicMock(code=0, msg="", data=None))
+    msg.apatch = AsyncMock(return_value=MagicMock(code=0, msg="", data=None))
+    msg.adelete = AsyncMock(return_value=MagicMock(code=0, msg="", data=None))
+    msg.aforward = AsyncMock(return_value=MagicMock(code=0, msg="", data=None))
+    msg.aget = AsyncMock(return_value=MagicMock(code=0, msg="", data=MagicMock()))
+    # im.v1.message_reaction.*
+    rx = c.im.v1.message_reaction
+    rx.acreate = AsyncMock(return_value=MagicMock(code=0, msg="", data=None))
+    rx.adelete = AsyncMock(return_value=MagicMock(code=0, msg="", data=None))
+    rx.alist = AsyncMock(return_value=MagicMock(code=0, msg="", data=MagicMock()))
+    return c
+
+
+@pytest.mark.asyncio
+async def test_create_message_builds_request():
+    c = _stub_client()
+    d = LarkClientDriver(c)
+    await d.create_message(
+        receive_id_type="chat_id",
+        receive_id="oc_1",
+        msg_type="text",
+        content='{"text": "hi"}',
+        uuid="u1",
+    )
+    call = c.im.v1.message.acreate.call_args
+    req = call.args[0]
+    assert req.receive_id_type == "chat_id"
+    assert req.body.receive_id == "oc_1"
+    assert req.body.msg_type == "text"
+    assert req.body.content == '{"text": "hi"}'
+    assert req.body.uuid == "u1"
+
+
+@pytest.mark.asyncio
+async def test_reply_message_sets_thread_flag():
+    c = _stub_client()
+    d = LarkClientDriver(c)
+    await d.reply_message(
+        message_id="om_x",
+        msg_type="text",
+        content='{"text":"t"}',
+        reply_in_thread=True,
+    )
+    call = c.im.v1.message.areply.call_args
+    req = call.args[0]
+    assert req.message_id == "om_x"
+    assert req.body.reply_in_thread is True
+
+
+@pytest.mark.asyncio
+async def test_delete_forward_patch_use_correct_path():
+    c = _stub_client()
+    d = LarkClientDriver(c)
+    await d.delete_message(message_id="om_del")
+    assert c.im.v1.message.adelete.await_count == 1
+    await d.patch_message(message_id="om_p", content="{}")
+    assert c.im.v1.message.apatch.await_count == 1
+    await d.forward_message(message_id="om_f", chat_id="oc_new")
+    assert c.im.v1.message.aforward.await_count == 1
+    fwd_call = c.im.v1.message.aforward.call_args
+    assert fwd_call.args[0].receive_id_type == "chat_id"
+    assert fwd_call.args[0].body.receive_id == "oc_new"
+
+
+@pytest.mark.asyncio
+async def test_update_message_sets_msg_type_and_content():
+    c = _stub_client()
+    d = LarkClientDriver(c)
+    await d.update_message(
+        message_id="om_update",
+        msg_type="post",
+        content='{"zh_cn":{"title":"","content":[]}}',
+    )
+    call = c.im.v1.message.aupdate.call_args
+    req = call.args[0]
+    assert req.message_id == "om_update"
+    assert req.body.msg_type == "post"
+    assert req.body.content == '{"zh_cn":{"title":"","content":[]}}'
+
+
+@pytest.mark.asyncio
+async def test_reaction_add_and_remove_call_correct_service():
+    c = _stub_client()
+    d = LarkClientDriver(c)
+    await d.add_reaction(message_id="om_1", emoji_type="THUMBSUP")
+    assert c.im.v1.message_reaction.acreate.await_count == 1
+    await d.remove_reaction(message_id="om_1", reaction_id="rxn_1")
+    assert c.im.v1.message_reaction.adelete.await_count == 1
+
+
+@pytest.mark.asyncio
+async def test_reaction_list_builds_filter_request():
+    c = _stub_client()
+    d = LarkClientDriver(c)
+
+    await d.list_reactions(
+        message_id="om_1",
+        emoji_type="THUMBSUP",
+        page_token="page_1",
+        page_size=20,
+    )
+
+    req = c.im.v1.message_reaction.alist.call_args.args[0]
+    assert req.paths["message_id"] == "om_1"
+    assert req.page_size == 20
+    assert dict(req.queries) == {
+        "reaction_type": "THUMBSUP",
+        "page_token": "page_1",
+        "page_size": "20",
+    }
diff --git a/lark_channel/channel/tests/test_duration_parsers.py b/lark_channel/channel/tests/test_duration_parsers.py
new file mode 100644
index 0000000..8cd05df
--- /dev/null
+++ b/lark_channel/channel/tests/test_duration_parsers.py
@@ -0,0 +1,136 @@
+"""Binary-format duration parsers — synthetic buffers for deterministic tests."""
+
+import struct
+
+from lark_channel.channel.outbound.media.duration_mp4 import parse_mp4_duration
+from lark_channel.channel.outbound.media.duration_ogg import parse_opus_duration
+
+
+# ---- OGG / Opus ---------------------------------------------------------
+
+
+def _ogg_page(granule: int) -> bytes:
+    """Build a minimal OggS page header with the given granule position."""
+    # Structure: "OggS"(4) + version(1) + type(1) + granule(8) + serial(4)
+    # + seq(4) + checksum(4) + n_segs(1) = 27 bytes total
+    header = b"OggS"
+    header += bytes([0])                      # version
+    header += bytes([4])                      # type = end of stream
+    header += struct.pack("<q", granule)      # granule position LE int64
+    header += struct.pack("<I", 1)            # serial number
+    header += struct.pack("<I", 0)            # page sequence
+    header += struct.pack("<I", 0)            # CRC
+    header += bytes([0])                      # page segments
+    return header
+
+
+def test_opus_duration_reads_final_granule():
+    # granule = 48000 → 1000 ms (48 kHz)
+    page = _ogg_page(48000)
+    assert parse_opus_duration(b"\x00" * 50 + page) == 1000
+
+
+def test_opus_duration_half_second():
+    page = _ogg_page(24000)
+    assert parse_opus_duration(page) == 500
+
+
+def test_opus_duration_uses_last_oggs_page():
+    """Multiple pages: parser should read the LAST one's granule."""
+    first = _ogg_page(24000)   # would be 500ms
+    last = _ogg_page(96000)    # should win: 2000ms
+    assert parse_opus_duration(first + b"\x00" * 32 + last) == 2000
+
+
+def test_opus_duration_none_for_empty_or_short_buffer():
+    assert parse_opus_duration(b"") is None
+    assert parse_opus_duration(b"tiny") is None
+
+
+def test_opus_duration_none_without_oggs_magic():
+    assert parse_opus_duration(b"A" * 100) is None
+
+
+def test_opus_duration_negative_granule_rejected():
+    # granule -1 as signed int64
+    page = _ogg_page(-1)
+    assert parse_opus_duration(page) is None
+
+
+# ---- MP4 / ISO BMFF ------------------------------------------------------
+
+
+def _box(typ: bytes, payload: bytes) -> bytes:
+    size = 8 + len(payload)
+    return struct.pack(">I", size) + typ + payload
+
+
+def _mvhd_v0(timescale: int, duration: int) -> bytes:
+    # version(1) + flags(3) + creation(4) + modification(4) + timescale(4)
+    # + duration(4) + rate(4) + volume(2) + reserved(10) + matrix(36)
+    # + pre_defined(24) + next_track_id(4) = 100 bytes
+    payload = bytes([0, 0, 0, 0])             # version + flags
+    payload += struct.pack(">I", 0)           # creation
+    payload += struct.pack(">I", 0)           # modification
+    payload += struct.pack(">I", timescale)
+    payload += struct.pack(">I", duration)
+    payload += b"\x00" * 76                   # rest (padded)
+    return _box(b"mvhd", payload)
+
+
+def _mvhd_v1(timescale: int, duration: int) -> bytes:
+    payload = bytes([1, 0, 0, 0])             # version 1 + flags
+    payload += struct.pack(">Q", 0)           # creation (64-bit)
+    payload += struct.pack(">Q", 0)           # modification (64-bit)
+    payload += struct.pack(">I", timescale)
+    payload += struct.pack(">Q", duration)    # duration (64-bit)
+    payload += b"\x00" * 80                   # rest
+    return _box(b"mvhd", payload)
+
+
+def test_mp4_duration_v0_box():
+    # timescale=1000 duration=5000 → 5000 ms
+    mvhd = _mvhd_v0(1000, 5000)
+    moov = _box(b"moov", mvhd)
+    # Prepend a skippable ftyp box to simulate a real file
+    ftyp = _box(b"ftyp", b"isom\x00\x00\x02\x00")
+    assert parse_mp4_duration(ftyp + moov) == 5000
+
+
+def test_mp4_duration_v1_box():
+    mvhd = _mvhd_v1(48000, 24000)   # timescale 48kHz, 24000 ticks = 500 ms
+    moov = _box(b"moov", mvhd)
+    assert parse_mp4_duration(moov) == 500
+
+
+def test_mp4_duration_missing_moov_returns_none():
+    ftyp = _box(b"ftyp", b"isom\x00\x00\x02\x00")
+    assert parse_mp4_duration(ftyp) is None
+
+
+def test_mp4_duration_missing_mvhd_returns_none():
+    moov = _box(b"moov", _box(b"trak", b"\x00" * 32))  # no mvhd inside
+    assert parse_mp4_duration(moov) is None
+
+
+def test_mp4_duration_zero_timescale_returns_none():
+    mvhd = _mvhd_v0(0, 5000)
+    moov = _box(b"moov", mvhd)
+    assert parse_mp4_duration(moov) is None
+
+
+def test_mp4_duration_extended_size_box():
+    """Box with size=1 indicates a 64-bit extended size follows."""
+    mvhd = _mvhd_v0(1000, 3000)
+    moov_payload = mvhd
+    # Construct moov with extended-size header
+    extended = b"\x00\x00\x00\x01" + b"moov" + struct.pack(">Q", 16 + len(moov_payload)) + moov_payload
+    assert parse_mp4_duration(extended) == 3000
+
+
+def test_mp4_duration_empty_returns_none():
+    assert parse_mp4_duration(b"") is None
+
+
+def test_mp4_duration_truncated_returns_none():
+    assert parse_mp4_duration(b"\x00\x00\x00\x08moov") is None  # header only, no payload
diff --git a/lark_channel/channel/tests/test_edit_message_polymorphic.py b/lark_channel/channel/tests/test_edit_message_polymorphic.py
new file mode 100644
index 0000000..2737be3
--- /dev/null
+++ b/lark_channel/channel/tests/test_edit_message_polymorphic.py
@@ -0,0 +1,110 @@
+"""Polymorphic edit_message materialization tests."""
+
+import json
+from unittest.mock import AsyncMock
+
+import pytest
+
+from lark_channel.channel import FeishuChannel
+from lark_channel.channel.config import MarkdownConverter, OutboundConfig
+from lark_channel.channel.outbound.sender import OutboundSender
+from lark_channel.channel.types import (
+    MediaSource,
+    OutboundCard,
+    OutboundImage,
+    OutboundPost,
+    OutboundText,
+)
+
+
+@pytest.mark.asyncio
+async def test_materialize_for_edit_text_body():
+    s = OutboundSender(driver=None)
+    body = await s.materialize_for_edit(OutboundText(text="plain"))
+    assert body["msg_type"] == "text"
+    assert json.loads(body["content"]) == {"text": "plain"}
+
+
+@pytest.mark.asyncio
+async def test_materialize_for_edit_markdown_native_body():
+    cfg = OutboundConfig(markdown_converter=MarkdownConverter(tag_md_mode="native"))
+    s = OutboundSender(driver=None, config=cfg)
+    body = await s.materialize_for_edit(OutboundPost(markdown="# H1"))
+    assert body["msg_type"] == "post"
+    content = json.loads(body["content"])
+    assert content["zh_cn"]["content"] == [[{"tag": "md", "text": "# H1"}]]
+
+
+@pytest.mark.asyncio
+async def test_materialize_for_edit_post_ast_opaque():
+    ast = {"zh_cn": {"title": "", "content": [[{"tag": "text", "text": "hi"}]]}}
+    s = OutboundSender(driver=None)
+    body = await s.materialize_for_edit(OutboundPost(post=ast))
+    assert body["msg_type"] == "post"
+    assert json.loads(body["content"]) == ast
+
+
+@pytest.fixture
+def channel():
+    ch = FeishuChannel(
+        app_id="cli_x",
+        app_secret="secret",
+        outbound=OutboundConfig(markdown_converter=MarkdownConverter(tag_md_mode="native")),
+    )
+    ch._driver.update_message = AsyncMock(return_value={"code": 0, "data": {"message_id": "om_1"}})
+    return ch
+
+
+@pytest.mark.asyncio
+async def test_edit_message_bare_string_aligns_with_send_as_markdown(channel):
+    result = await channel.edit_message("om_1", "# H1")
+    assert result.success is True
+    channel._driver.update_message.assert_awaited_once()
+    kwargs = channel._driver.update_message.await_args.kwargs
+    assert kwargs["message_id"] == "om_1"
+    assert kwargs["msg_type"] == "post"
+    content = json.loads(kwargs["content"])
+    assert content["zh_cn"]["content"] == [[{"tag": "md", "text": "# H1"}]]
+
+
+@pytest.mark.asyncio
+async def test_edit_message_text_dict_stays_text(channel):
+    await channel.edit_message("om_1", {"text": "# literal"})
+    kwargs = channel._driver.update_message.await_args.kwargs
+    assert kwargs["msg_type"] == "text"
+    assert json.loads(kwargs["content"]) == {"text": "# literal"}
+
+
+@pytest.mark.asyncio
+async def test_edit_message_markdown_dict_is_post(channel):
+    await channel.edit_message("om_1", {"markdown": "**bold**"})
+    kwargs = channel._driver.update_message.await_args.kwargs
+    assert kwargs["msg_type"] == "post"
+    content = json.loads(kwargs["content"])
+    assert content["zh_cn"]["content"] == [[{"tag": "md", "text": "**bold**"}]]
+
+
+@pytest.mark.asyncio
+async def test_edit_message_post_dict_is_opaque(channel):
+    ast = {"zh_cn": {"title": "", "content": [[{"tag": "text", "text": "opaque"}]]}}
+    await channel.edit_message("om_1", {"post": ast})
+    kwargs = channel._driver.update_message.await_args.kwargs
+    assert kwargs["msg_type"] == "post"
+    assert json.loads(kwargs["content"]) == ast
+
+
+@pytest.mark.asyncio
+async def test_edit_message_rejects_card_and_mentions_update_card(channel):
+    with pytest.raises(TypeError, match="update_card"):
+        await channel.edit_message("om_1", OutboundCard(card={"schema": "2.0"}))
+    channel._driver.update_message.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_edit_message_rejects_media(channel):
+    with pytest.raises(TypeError, match="text/post"):
+        await channel.edit_message(
+            "om_1",
+            OutboundImage(source=MediaSource(kind="key", key="img_x")),
+        )
+    channel._driver.update_message.assert_not_called()
diff --git a/lark_channel/channel/tests/test_errors.py b/lark_channel/channel/tests/test_errors.py
new file mode 100644
index 0000000..18b7733
--- /dev/null
+++ b/lark_channel/channel/tests/test_errors.py
@@ -0,0 +1,44 @@
+"""Error classification tests."""
+
+from lark_channel.channel.errors import FeishuChannelErrorCode, classify_error
+
+
+def test_token_invalid_is_retryable():
+    e = classify_error(99991663, "expired")
+    assert e.code == FeishuChannelErrorCode.PERMISSION_DENIED
+    assert e.retryable is True
+
+
+def test_rate_limit():
+    assert classify_error(11020).code == FeishuChannelErrorCode.RATE_LIMITED
+
+
+def test_target_revoked():
+    assert classify_error(230002).code == FeishuChannelErrorCode.TARGET_REVOKED
+
+
+def test_length_exceed_maps_to_format_error():
+    e = classify_error(230021)
+    assert e.code == FeishuChannelErrorCode.FORMAT_ERROR
+    assert e.retryable is False
+
+
+def test_5xx_maps_to_unknown_retryable():
+    assert classify_error(500).code == FeishuChannelErrorCode.UNKNOWN
+    assert classify_error(500).retryable is True
+    assert classify_error(50100).code == FeishuChannelErrorCode.UNKNOWN
+
+
+def test_unknown_defaults():
+    e = classify_error(123456)
+    assert e.code == FeishuChannelErrorCode.UNKNOWN
+    assert e.retryable is False
+
+
+def test_zero_is_unknown_and_non_retryable():
+    assert classify_error(0).retryable is False
+
+
+def test_download_failed_enum_value_exists():
+    from lark_channel.channel import FeishuChannelErrorCode
+    assert FeishuChannelErrorCode.DOWNLOAD_FAILED.value == "download_failed"
diff --git a/lark_channel/channel/tests/test_errors_helpers.py b/lark_channel/channel/tests/test_errors_helpers.py
new file mode 100644
index 0000000..3344728
--- /dev/null
+++ b/lark_channel/channel/tests/test_errors_helpers.py
@@ -0,0 +1,103 @@
+"""Coverage for classify_api_error / classify_http_status / is_retryable /
+is_reply_target_gone / is_format_error / FeishuChannelError."""
+
+from lark_channel.channel.errors import (
+    FeishuChannelError,
+    FeishuChannelErrorCode,
+    classify_api_error,
+    classify_http_status,
+    is_format_error,
+    is_reply_target_gone,
+    is_retryable,
+)
+
+
+def test_feishu_channel_error_code_has_10_canonical_values():
+    canonical = {
+        "format_error", "target_revoked", "rate_limited", "permission_denied",
+        "upload_failed", "download_failed", "ssrf_blocked", "send_timeout",
+        "not_connected", "unknown",
+    }
+    assert {m.value for m in FeishuChannelErrorCode} == canonical
+
+
+def test_feishu_channel_error_construction():
+    err = FeishuChannelError(FeishuChannelErrorCode.FORMAT_ERROR, "bad card", context={"to": "oc_x"})
+    assert err.code == FeishuChannelErrorCode.FORMAT_ERROR
+    assert err.context == {"to": "oc_x"}
+    assert "format_error" in repr(err) or "bad card" in repr(err)
+
+
+def test_feishu_channel_error_default_message_uses_code():
+    err = FeishuChannelError(FeishuChannelErrorCode.NOT_CONNECTED)
+    assert err.args[0] == "not_connected"
+
+
+def test_classify_api_error_target_revoked_family():
+    # 230001 is NOT target_revoked — it is "invalid message content" (format error).
+    # Regression: putting 230001 in the target_revoked bucket triggered the
+    # reply-gone → fresh-create fallback, hiding schema bugs until prod.
+    for code in (230020, 230017, 230002, 230005):
+        assert classify_api_error(code) == FeishuChannelErrorCode.TARGET_REVOKED, code
+
+
+def test_classify_api_error_230001_is_format_error_not_target_revoked():
+    # See Feishu error-code docs: 230001 "invalid message content" =
+    # malformed body / schema violation. Must route through the plain-text
+    # fallback path (is_format_error), not the reply-gone path.
+    from lark_channel.channel.errors import classify_error, is_format_error
+
+    assert classify_api_error(230001) == FeishuChannelErrorCode.FORMAT_ERROR
+    err = classify_error(230001, "invalid message content")
+    assert is_format_error(err.code)
+
+
+def test_classify_api_error_permission_denied_family():
+    for code in (99991400, 99991401, 99991672, 99991679, 99991680, 99991681, 230003, 230010):
+        assert classify_api_error(code) == FeishuChannelErrorCode.PERMISSION_DENIED, code
+
+
+def test_classify_api_error_rate_limited_family():
+    for code in (99991402, 11020, 11021):
+        assert classify_api_error(code) == FeishuChannelErrorCode.RATE_LIMITED, code
+
+
+def test_classify_api_error_format_family():
+    for code in (230099, 230021, 230022):
+        assert classify_api_error(code) == FeishuChannelErrorCode.FORMAT_ERROR, code
+
+
+def test_classify_api_error_unknown_fallback():
+    assert classify_api_error(123456) == FeishuChannelErrorCode.UNKNOWN
+
+
+def test_classify_api_error_zero_is_unknown():
+    assert classify_api_error(0) == FeishuChannelErrorCode.UNKNOWN
+
+
+def test_classify_http_status_mapping():
+    assert classify_http_status(429) == FeishuChannelErrorCode.RATE_LIMITED
+    assert classify_http_status(401) == FeishuChannelErrorCode.PERMISSION_DENIED
+    assert classify_http_status(403) == FeishuChannelErrorCode.PERMISSION_DENIED
+    assert classify_http_status(404) == FeishuChannelErrorCode.TARGET_REVOKED
+    assert classify_http_status(400) == FeishuChannelErrorCode.FORMAT_ERROR
+    assert classify_http_status(503) == FeishuChannelErrorCode.UNKNOWN
+    assert classify_http_status(200) == FeishuChannelErrorCode.UNKNOWN
+
+
+def test_is_retryable_predicate():
+    assert is_retryable(FeishuChannelErrorCode.RATE_LIMITED) is True
+    assert is_retryable(FeishuChannelErrorCode.UNKNOWN) is True
+    assert is_retryable(FeishuChannelErrorCode.FORMAT_ERROR) is False
+    assert is_retryable(FeishuChannelErrorCode.TARGET_REVOKED) is False
+    assert is_retryable(FeishuChannelErrorCode.PERMISSION_DENIED) is False
+
+
+def test_is_reply_target_gone_predicate():
+    assert is_reply_target_gone(FeishuChannelErrorCode.TARGET_REVOKED) is True
+    assert is_reply_target_gone(FeishuChannelErrorCode.FORMAT_ERROR) is False
+
+
+def test_is_format_error_predicate():
+    assert is_format_error(FeishuChannelErrorCode.FORMAT_ERROR) is True
+    assert is_format_error(FeishuChannelErrorCode.UNKNOWN) is False
diff --git a/lark_channel/channel/tests/test_feishu_channel.py b/lark_channel/channel/tests/test_feishu_channel.py
new file mode 100644
index 0000000..c1f7bb0
--- /dev/null
+++ b/lark_channel/channel/tests/test_feishu_channel.py
@@ -0,0 +1,169 @@
+"""Tests for the Node-aligned FeishuChannel facade."""
+
+from unittest.mock import AsyncMock
+
+import pytest
+
+from lark_channel.channel import FeishuChannel, RejectEvent
+from lark_channel.channel._coerce import (
+    coerce_outbound as _coerce_outbound,
+    coerce_send_opts as _coerce_send_opts,
+    normalize_event_name as _normalize_event_name,
+)
+from lark_channel.channel.types import (
+    OutboundCard,
+    OutboundFile,
+    OutboundImage,
+    OutboundPost,
+    OutboundText,
+    SendOpts,
+    SendResult,
+)
+
+
+# ---- input coercion --------------------------------------------------------
+
+
+def test_coerce_string_defaults_to_markdown():
+    ob = _coerce_outbound("**hi**")
+    assert isinstance(ob, OutboundPost) and ob.markdown == "**hi**"
+
+
+def test_coerce_dict_inputs_by_key():
+    assert isinstance(_coerce_outbound({"markdown": "hi"}), OutboundPost)
+    assert isinstance(_coerce_outbound({"text": "hi"}), OutboundText)
+    assert isinstance(_coerce_outbound({"post": {}}), OutboundPost)
+    assert isinstance(_coerce_outbound({"card": {}}), OutboundCard)
+
+
+def test_coerce_image_with_url():
+    ob = _coerce_outbound({"image": {"source": "https://example.com/x.png"}})
+    assert isinstance(ob, OutboundImage)
+    assert ob.source.kind == "url"
+    assert ob.source.url == "https://example.com/x.png"
+
+
+def test_coerce_image_with_key():
+    ob = _coerce_outbound({"image": {"source": "img_abcdef"}})
+    assert isinstance(ob, OutboundImage)
+    assert ob.source.kind == "key"
+    assert ob.source.key == "img_abcdef"
+
+
+def test_coerce_file_with_filename():
+    ob = _coerce_outbound({"file": {"source": b"\x00\x01", "fileName": "x.pdf"}})
+    assert isinstance(ob, OutboundFile) and ob.file_name == "x.pdf"
+
+
+def test_coerce_send_opts_camel_and_snake():
+    opts = _coerce_send_opts({"replyTo": "om_x", "reply_in_thread": True})
+    assert opts.reply_to == "om_x" and opts.reply_in_thread is True
+
+
+def test_coerce_send_opts_passthrough_sendopts():
+    so = SendOpts(reply_to="om_y")
+    assert _coerce_send_opts(so) is so
+
+
+# ---- event name normalization ----------------------------------------------
+
+
+def test_event_name_aliases_collapse_to_node_names():
+    assert _normalize_event_name("interaction") == "cardAction"
+    assert _normalize_event_name("bot_added") == "botAdded"
+    assert _normalize_event_name("bot_leave") == "botLeave"
+    assert _normalize_event_name("message_read") == "messageRead"
+
+
+# ---- FeishuChannel.on / off / reject wiring --------------------------------
+
+
+@pytest.fixture
+def channel():
+    c = FeishuChannel(app_id="cli_test", app_secret="s")
+    return c
+
+
+def test_on_registers_and_unsubscribes(channel):
+    calls = []
+
+    def h(msg):
+        calls.append(msg)
+
+    unsub = channel.on("message", h)
+    # Handlers are stored as a list so multiple subscribers can co-exist.
+    for fn in channel._handlers.get("message", []):
+        fn(None)
+    assert len(calls) == 1
+    unsub()
+    # The list is cleared and the key pruned on final unsubscribe.
+    assert channel._handlers.get("message") is None
+
+
+def test_on_appends_multiple_handlers(channel):
+    # New semantics: on() appends rather than replacing. Aligns with node-sdk
+    # and with the EventEmitter / pub-sub pattern Python users expect.
+    calls = []
+    channel.on("message", lambda m: calls.append("a"))
+    channel.on("message", lambda m: calls.append("b"))
+    for fn in channel._handlers.get("message", []):
+        fn(None)
+    assert calls == ["a", "b"]
+
+
+def test_on_dict_form_registers_many(channel):
+    got = {}
+
+    channel.on({
+        "message": lambda m: got.setdefault("m", 1),
+        "cardAction": lambda e: got.setdefault("c", 1),
+    })
+    assert "message" in channel._handlers
+    assert "cardAction" in channel._handlers
+
+
+def test_reject_handler_receives_reject_event(channel):
+    received = []
+    channel.on("reject", lambda e: received.append(e))
+    # Simulate safety pipeline emitting a reject
+    channel._emit_reject(RejectEvent(
+        message_id="om_x", chat_id="oc_1", sender_id="ou_s",
+        reason="policy_no_mention",
+    ))
+    assert received[0].reason == "policy_no_mention"
+
+
+# ---- send routing ----------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_send_markdown_string_uses_post_sender(channel):
+    channel._sender = AsyncMock()  # type: ignore[attr-defined]
+    channel._sender.send = AsyncMock(return_value=SendResult.ok(message_id="om_ok"))
+    await channel.send("oc_123", "**hi**")
+    call = channel._sender.send.call_args
+    # OutboundPost was constructed
+    sent_msg = call.args[0]
+    assert isinstance(sent_msg, OutboundPost) and sent_msg.markdown == "**hi**"
+
+
+@pytest.mark.asyncio
+async def test_send_infers_receive_id_type_from_prefix(channel):
+    channel._sender = AsyncMock()
+    channel._sender.send = AsyncMock(return_value=SendResult.ok(message_id="om_ok"))
+    await channel.send("ou_someone", {"text": "hi"})
+    call = channel._sender.send.call_args
+    assert call.kwargs["receive_id_type"] == "open_id"
+    await channel.send("oc_group", {"text": "hi"})
+    call = channel._sender.send.call_args
+    assert call.kwargs["receive_id_type"] == "chat_id"
+
+
+# ---- update_policy + get_policy --------------------------------------------
+
+
+def test_update_policy_patches_live(channel):
+    # Force bg loop + safety pipeline up
+    channel._ensure_bg_loop()
+    channel.update_policy(require_mention=False)
+    assert channel.get_policy().require_mention is False
diff --git a/lark_channel/channel/tests/test_flatten.py b/lark_channel/channel/tests/test_flatten.py
new file mode 100644
index 0000000..9806b28
--- /dev/null
+++ b/lark_channel/channel/tests/test_flatten.py
@@ -0,0 +1,228 @@
+"""Tests for flat-string content + resources[] derivation (Node-aligned)."""
+
+from lark_channel.channel.normalize.flatten import flatten
+from lark_channel.channel.types import (
+    AudioContent,
+    FileContent,
+    FolderContent,
+    GeneralCalendarContent,
+    HongbaoContent,
+    ImageContent,
+    InteractiveContent,
+    LocationContent,
+    MediaContent,
+    MergeForwardContent,
+    MergeForwardItem,
+    PostContent,
+    ShareCalendarEventContent,
+    ShareChatContent,
+    ShareUserContent,
+    StickerContent,
+    TextContent,
+    UnknownContent,
+)
+
+
+def test_text_flat_passthrough():
+    t, r = flatten(TextContent(text="hello"))
+    assert t == "hello" and r == []
+
+
+def test_image_markdown_placeholder_plus_resource():
+    t, r = flatten(ImageContent(image_key="img_abc"))
+    assert t == "![image](img_abc)"
+    assert len(r) == 1
+    assert r[0].type == "image" and r[0].file_key == "img_abc"
+
+
+def test_file_xml_placeholder_resource_has_name():
+    t, r = flatten(FileContent(file_key="f_x", file_name="report.pdf"))
+    assert "key=\"f_x\"" in t and "report.pdf" in t
+    assert r[0].type == "file" and r[0].file_name == "report.pdf"
+
+
+def test_video_uses_media_content_with_cover():
+    t, r = flatten(MediaContent(file_key="v_1", image_key="cov_1", duration_ms=3000))
+    assert "<video " in t and 'key="v_1"' in t
+    assert r[0].type == "video" and r[0].cover_image_key == "cov_1"
+
+
+def test_audio_and_sticker_emit_resource():
+    _, ra = flatten(AudioContent(file_key="a_1", duration_ms=1500))
+    assert ra[0].type == "audio" and ra[0].duration_ms == 1500
+    _, rs = flatten(StickerContent(file_key="s_1"))
+    assert rs[0].type == "sticker"
+
+
+def test_share_chat_and_user_emit_tag_only():
+    t, _ = flatten(ShareChatContent(chat_id="oc_123"))
+    assert "<group_card" in t and "oc_123" in t
+    t, _ = flatten(ShareUserContent(user_id="ou_456"))
+    assert "<contact_card" in t
+
+
+def test_location_tag():
+    t, _ = flatten(LocationContent(name="HQ", longitude=116.4, latitude=39.9))
+    assert "<location" in t and "HQ" in t
+
+
+def test_folder_hongbao_tags():
+    # Folder requires a file_key (node-aligned); falls back to [folder] without one.
+    assert "<folder" in flatten(FolderContent(file_key="fk_1", file_name="docs"))[0]
+    assert "[folder]" == flatten(FolderContent(file_name="docs"))[0]
+    assert "<hongbao" in flatten(HongbaoContent(text="新年快乐"))[0]
+
+
+def test_general_calendar_and_share_calendar_event():
+    # Node-aligned tags: GeneralCalendar → <calendar>, ShareCalendarEvent → <calendar_share>.
+    assert "<calendar>" in flatten(GeneralCalendarContent(summary="Sync"))[0]
+    assert "<calendar_share>" in flatten(
+        ShareCalendarEventContent(summary="Demo", organizer="Alice")
+    )[0]
+
+
+def test_post_to_markdown_style_mapping():
+    post = {
+        "zh_cn": {
+            "title": "Title",
+            "content": [
+                [
+                    {"tag": "text", "text": "bold bit", "style": ["bold"]},
+                    {"tag": "text", "text": " normal "},
+                    {"tag": "a", "text": "link", "href": "https://x"},
+                ],
+                [{"tag": "code_block", "language": "python", "text": "print(1)"}],
+            ],
+        }
+    }
+    t, _ = flatten(PostContent(post=post))
+    assert "# Title" in t
+    assert "**bold bit**" in t
+    assert "[link](https://x)" in t
+    assert "```python" in t
+
+
+def test_post_resources_include_images_media_audio_and_files_deduped():
+    post = {
+        "zh_cn": {
+            "title": "Assets",
+            "content": [
+                [
+                    {"tag": "text", "text": "see "},
+                    {"tag": "img", "image_key": "img_1"},
+                    {"tag": "img", "image_key": "img_1"},
+                    {"tag": "media", "file_key": "vid_1"},
+                ],
+                [
+                    {"tag": "audio", "file_key": "aud_1"},
+                    {"tag": "file", "file_key": "file_1", "file_name": "report.pdf"},
+                ],
+            ],
+        }
+    }
+
+    t, r = flatten(PostContent(post=post))
+
+    assert "![image](img_1)" in t
+    assert "[media:vid_1]" in t
+    assert [(x.type, x.file_key, x.file_name) for x in r] == [
+        ("image", "img_1", None),
+        ("video", "vid_1", None),
+        ("audio", "aud_1", None),
+        ("file", "file_1", "report.pdf"),
+    ]
+
+
+def test_post_direct_document_shape_flattens_text_and_resources():
+    post = {
+        "title": "Direct",
+        "content": [
+            [
+                {"tag": "text", "text": "hello "},
+                {"tag": "a", "text": "link", "href": "https://x"},
+                {"tag": "img", "image_key": "img_direct"},
+            ]
+        ],
+    }
+
+    t, r = flatten(PostContent(post=post))
+
+    assert "# Direct" in t
+    assert "[link](https://x)" in t
+    assert r[0].type == "image"
+    assert r[0].file_key == "img_direct"
+
+
+def test_merge_forward_flatten_recursive():
+    child = TextContent(text="child content")
+    item = MergeForwardItem(
+        message_id="c1",
+        sender_name="Alice",
+        create_time=int(__import__("time").time() * 1000),
+        content=child,
+    )
+    content = MergeForwardContent(loading=False, items=[item])
+    t, r = flatten(content)
+    assert "<forwarded_messages>" in t
+    assert "Alice:" in t
+    assert "child content" in t
+
+
+def test_merge_forward_flatten_handles_deep_tree_without_recursion_error():
+    child = TextContent(text="deep child")
+    for index in range(1200):
+        child = MergeForwardContent(
+            loading=False,
+            items=[
+                MergeForwardItem(
+                    message_id=f"m_{index}",
+                    sender_name="Alice",
+                    create_time=0,
+                    content=child,
+                )
+            ],
+        )
+
+    t, _ = flatten(child)
+
+    assert "deep child" in t
+
+
+def test_interactive_walk_picks_markdown_leaves():
+    card = {
+        "schema": "2.0",
+        "header": {
+            "title": {"tag": "plain_text", "content": "Header"},
+            "subtitle": {"tag": "plain_text", "content": "sub"},
+        },
+        "body": {
+            "elements": [
+                {"tag": "markdown", "content": "body1"},
+                {"tag": "column_set", "columns": [
+                    {"tag": "column", "elements": [
+                        {"tag": "markdown", "content": "in column"},
+                    ]},
+                ]},
+            ],
+        },
+    }
+    t, _ = flatten(InteractiveContent(card=card, card_version="v2"))
+    for expected in ["Header", "body1", "in column"]:
+        assert expected in t
+
+
+def test_interactive_walk_handles_deep_card_without_recursion_error():
+    node = {"tag": "markdown", "content": "deep leaf"}
+    for _ in range(1500):
+        node = {"tag": "column_set", "columns": [{"tag": "column", "elements": [node]}]}
+
+    t, _ = flatten(InteractiveContent(card={"body": {"elements": [node]}}, card_version="v2"))
+
+    assert "deep leaf" in t
+
+
+def test_unknown_fallback_uses_raw_text():
+    t, _ = flatten(UnknownContent(raw={"text": "raw text"}))
+    assert t == "raw text"
+    t, _ = flatten(UnknownContent(raw={}))
+    assert t == "[unsupported message]"
diff --git a/lark_channel/channel/tests/test_handle_webhook_request.py b/lark_channel/channel/tests/test_handle_webhook_request.py
new file mode 100644
index 0000000..e31558b
--- /dev/null
+++ b/lark_channel/channel/tests/test_handle_webhook_request.py
@@ -0,0 +1,789 @@
+"""Tests for FeishuChannel.handle_webhook_request."""
+
+import base64
+import hashlib
+import json
+import logging
+
+import pytest
+from Crypto.Cipher import AES
+
+from lark_channel.card.action_handler import CardActionHandler
+from lark_channel.channel import FeishuChannel, SecurityConfig
+from lark_channel.core.const import (
+    LARK_REQUEST_NONCE,
+    LARK_REQUEST_SIGNATURE,
+    LARK_REQUEST_TIMESTAMP,
+)
+from lark_channel.core.model import RawRequest
+from lark_channel.event.dispatcher_handler import EventDispatcherHandler
+from lark_channel.event.security import (
+    InMemorySecurityAuditRecorder,
+    REASON_CARD_SIGNATURE_INVALID,
+    REASON_CARD_SIGNATURE_MISSING,
+    REASON_WEBHOOK_SIGNATURE_INVALID,
+    REASON_WEBHOOK_SIGNATURE_MISSING,
+)
+
+
+def _request(body, headers=None):
+    req = RawRequest()
+    req.uri = "/callback"
+    req.body = json.dumps(body).encode("utf-8")
+    req.headers = headers or {}
+    return req
+
+
+def _request_bytes(body, headers=None):
+    req = RawRequest()
+    req.uri = "/callback"
+    req.body = body
+    req.headers = headers or {}
+    return req
+
+
+def _signature_headers():
+    return {
+        LARK_REQUEST_SIGNATURE: "signature-from-upstream",
+        LARK_REQUEST_TIMESTAMP: "1778579753",
+        LARK_REQUEST_NONCE: "nonce",
+    }
+
+
+def _encrypted_body(plaintext, encrypt_key):
+    raw = json.dumps(plaintext).encode("utf-8")
+    key = hashlib.sha256(encrypt_key.encode("utf-8")).digest()
+    iv = b"0123456789abcdef"
+    pad = AES.block_size - (len(raw) % AES.block_size)
+    encrypted = AES.new(key, AES.MODE_CBC, iv).encrypt(raw + bytes([pad]) * pad)
+    payload = {"encrypt": base64.b64encode(iv + encrypted).decode("ascii")}
+    return json.dumps(payload).encode("utf-8")
+
+
+def _signed_headers(body, secret, *, algorithm="sha256"):
+    timestamp = "1778579753"
+    nonce = "nonce"
+    data = (timestamp + nonce + secret).encode("utf-8") + body
+    if algorithm == "sha1":
+        signature = hashlib.sha1(data).hexdigest()
+    else:
+        signature = hashlib.sha256(data).hexdigest()
+    return {
+        LARK_REQUEST_SIGNATURE: signature,
+        LARK_REQUEST_TIMESTAMP: timestamp,
+        LARK_REQUEST_NONCE: nonce,
+    }
+
+
+@pytest.mark.asyncio
+async def test_url_verification_challenge_returns_200():
+    """A challenge request must round-trip the challenge value."""
+    ch = FeishuChannel(
+        app_id="cli_x", app_secret="x", verification_token="vtok",
+        transport="webhook",
+    )
+    ch.start()  # webhook mode: builds dispatcher, no WS connect
+    try:
+        body = json.dumps({
+            "type": "url_verification",
+            "challenge": "abc-123",
+            "token": "vtok",
+        }).encode("utf-8")
+        status, response_body = await ch.handle_webhook_request(headers={}, body=body)
+        assert status == 200
+        assert b"abc-123" in response_body
+    finally:
+        await ch.stop_background()
+        ch.stop()
+
+
+@pytest.mark.asyncio
+async def test_invalid_token_yields_500():
+    """Mismatched verification_token must surface as a non-200 response."""
+    ch = FeishuChannel(
+        app_id="cli_x", app_secret="x", verification_token="vtok",
+        transport="webhook",
+    )
+    ch.start()
+    try:
+        body = json.dumps({
+            "type": "url_verification",
+            "challenge": "abc",
+            "token": "WRONG",
+        }).encode("utf-8")
+        status, _ = await ch.handle_webhook_request(headers={}, body=body)
+        assert status >= 400
+    finally:
+        await ch.stop_background()
+        ch.stop()
+
+
+@pytest.mark.asyncio
+async def test_unknown_event_does_not_raise():
+    """A well-formed but unknown event yields a non-2xx but does not raise."""
+    ch = FeishuChannel(
+        app_id="cli_x", app_secret="x", verification_token="vtok",
+        transport="webhook",
+    )
+    ch.start()
+    try:
+        body = json.dumps({
+            "schema": "2.0",
+            "header": {"event_type": "this.event.does.not.exist", "token": "vtok"},
+        }).encode("utf-8")
+        status, body_out = await ch.handle_webhook_request(headers={}, body=body)
+        assert isinstance(status, int)
+        assert isinstance(body_out, (bytes, bytearray))
+    finally:
+        await ch.stop_background()
+        ch.stop()
+
+
+@pytest.mark.asyncio
+async def test_returns_bytes_for_response_body():
+    """Output body must be bytes for direct write to wire."""
+    ch = FeishuChannel(
+        app_id="cli_x", app_secret="x", verification_token="vtok",
+        transport="webhook",
+    )
+    ch.start()
+    try:
+        body = json.dumps({
+            "type": "url_verification",
+            "challenge": "x",
+            "token": "vtok",
+        }).encode("utf-8")
+        status, body_out = await ch.handle_webhook_request(headers={}, body=body)
+        assert isinstance(body_out, (bytes, bytearray))
+    finally:
+        await ch.stop_background()
+        ch.stop()
+
+
+def test_plaintext_event_with_signature_header_does_not_require_encrypt_key():
+    seen = []
+    handler = (
+        EventDispatcherHandler.builder("", "verification-token")
+        .register_p2_customized_event("example.event", lambda event: seen.append(event))
+        .build()
+    )
+
+    resp = handler.do(
+        _request(
+            {
+                "schema": "2.0",
+                "header": {
+                    "event_type": "example.event",
+                    "token": "verification-token",
+                },
+                "event": {"value": "ok"},
+            },
+            _signature_headers(),
+        )
+    )
+
+    assert resp.status_code == 200
+    assert resp.content == b'{"msg":"success"}'
+    assert len(seen) == 1
+
+
+def test_event_url_verification_does_not_require_signature_before_dispatch():
+    handler = EventDispatcherHandler.builder("encrypt-key", "verification-token").build()
+
+    resp = handler.do(
+        _request(
+            {
+                "type": "url_verification",
+                "challenge": "challenge-code",
+                "token": "verification-token",
+            }
+        )
+    )
+
+    assert resp.status_code == 200
+    assert json.loads(resp.content) == {"challenge": "challenge-code"}
+
+
+def test_card_callback_with_signature_header_does_not_require_verification_token():
+    seen = []
+    handler = CardActionHandler.builder("", "").register(lambda card: seen.append(card)).build()
+
+    resp = handler.do(
+        _request(
+            {
+                "type": "card.action.trigger",
+                "action": {"value": {"key": "value"}},
+            },
+            _signature_headers(),
+        )
+    )
+
+    assert resp.status_code == 200
+    assert resp.content == b'{"msg":"success"}'
+    assert len(seen) == 1
+
+
+def test_signed_encrypted_event_is_verified_before_dispatch():
+    seen = []
+    body = _encrypted_body(
+        {
+            "schema": "2.0",
+            "header": {
+                "event_type": "example.event",
+                "token": "verification-token",
+            },
+            "event": {"value": "ok"},
+        },
+        "encrypt-key",
+    )
+    handler = (
+        EventDispatcherHandler.builder("encrypt-key", "verification-token")
+        .register_p2_customized_event("example.event", lambda event: seen.append(event))
+        .build()
+    )
+
+    resp = handler.do(
+        _request_bytes(body, _signed_headers(body, "encrypt-key", algorithm="sha256"))
+    )
+
+    assert resp.status_code == 200
+    assert resp.content == b'{"msg":"success"}'
+    assert len(seen) == 1
+
+
+def test_strict_event_invalid_signature_rejects_before_decrypt(monkeypatch):
+    recorder = InMemorySecurityAuditRecorder()
+    body = _encrypted_body({"type": "url_verification"}, "encrypt-key")
+
+    def fail_decrypt(*_args, **_kwargs):
+        raise AssertionError("decrypt should not run")
+
+    monkeypatch.setattr(
+        "lark_channel.event.dispatcher_handler.AESCipher.decrypt_str",
+        fail_decrypt,
+    )
+    handler = EventDispatcherHandler.builder(
+        "encrypt-key",
+        "verification-token",
+        security=SecurityConfig(mode="strict", audit_recorder=recorder),
+    ).build()
+
+    resp = handler.do(
+        _request_bytes(
+            body,
+            {
+                **_signed_headers(body, "wrong-key", algorithm="sha256"),
+            },
+        )
+    )
+
+    assert resp.status_code == 500
+    assert json.loads(resp.content) == {"code": 500, "msg": "internal error"}
+    assert [event.reason for event in recorder.events] == [
+        REASON_WEBHOOK_SIGNATURE_INVALID
+    ]
+
+
+def test_strict_event_missing_signature_rejects_before_decrypt(monkeypatch):
+    recorder = InMemorySecurityAuditRecorder()
+    body = _encrypted_body({"type": "url_verification"}, "encrypt-key")
+
+    def fail_decrypt(*_args, **_kwargs):
+        raise AssertionError("decrypt should not run")
+
+    monkeypatch.setattr(
+        "lark_channel.event.dispatcher_handler.AESCipher.decrypt_str",
+        fail_decrypt,
+    )
+    handler = EventDispatcherHandler.builder(
+        "encrypt-key",
+        "verification-token",
+        security=SecurityConfig(mode="strict", audit_recorder=recorder),
+    ).build()
+
+    resp = handler.do(_request_bytes(body, {}))
+
+    assert resp.status_code == 500
+    assert json.loads(resp.content) == {"code": 500, "msg": "internal error"}
+    assert [event.reason for event in recorder.events] == [
+        REASON_WEBHOOK_SIGNATURE_MISSING
+    ]
+
+
+def test_strict_event_unsigned_encrypted_allow_records_allow_action():
+    seen = []
+    recorder = InMemorySecurityAuditRecorder()
+    body = _encrypted_body(
+        {
+            "schema": "2.0",
+            "header": {
+                "event_type": "example.event",
+                "token": "verification-token",
+            },
+            "event": {"value": "ok"},
+        },
+        "encrypt-key",
+    )
+    handler = (
+        EventDispatcherHandler.builder(
+            "encrypt-key",
+            "verification-token",
+            security=SecurityConfig(
+                mode="strict",
+                allow_unsigned_encrypted_webhook=True,
+                audit_recorder=recorder,
+            ),
+        )
+        .register_p2_customized_event("example.event", lambda event: seen.append(event))
+        .build()
+    )
+
+    resp = handler.do(_request_bytes(body, {}))
+
+    assert resp.status_code == 200
+    assert len(seen) == 1
+    assert [event.reason for event in recorder.events] == [
+        REASON_WEBHOOK_SIGNATURE_MISSING
+    ]
+    assert recorder.events[0].action == "allow"
+
+
+@pytest.mark.parametrize("mode", ["compat", "audit"])
+def test_unsigned_encrypted_event_legacy_flow_is_not_blocked(mode):
+    seen = []
+    recorder = InMemorySecurityAuditRecorder()
+    body = _encrypted_body(
+        {
+            "schema": "2.0",
+            "header": {
+                "event_type": "example.event",
+                "token": "verification-token",
+            },
+            "event": {"value": "ok"},
+        },
+        "encrypt-key",
+    )
+    handler = (
+        EventDispatcherHandler.builder(
+            "encrypt-key",
+            "verification-token",
+            security=SecurityConfig(mode=mode, audit_recorder=recorder),
+        )
+        .register_p2_customized_event("example.event", lambda event: seen.append(event))
+        .build()
+    )
+
+    resp = handler.do(_request_bytes(body, {}))
+
+    assert resp.status_code == 200
+    assert resp.content == b'{"msg":"success"}'
+    assert len(seen) == 1
+    assert [event.reason for event in recorder.events] == [
+        REASON_WEBHOOK_SIGNATURE_MISSING
+    ]
+
+
+def test_unsigned_encrypted_event_default_compat_does_not_log_audit(caplog):
+    seen = []
+    body = _encrypted_body(
+        {
+            "schema": "2.0",
+            "header": {
+                "event_type": "example.event",
+                "token": "verification-token",
+            },
+            "event": {"value": "ok"},
+        },
+        "encrypt-key",
+    )
+    handler = (
+        EventDispatcherHandler.builder(
+            "encrypt-key",
+            "verification-token",
+            security=SecurityConfig(mode="compat"),
+        )
+        .register_p2_customized_event("example.event", lambda event: seen.append(event))
+        .build()
+    )
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        resp = handler.do(_request_bytes(body, {}))
+
+    assert resp.status_code == 200
+    assert len(seen) == 1
+    assert "security audit" not in caplog.text
+
+
+def test_signed_encrypted_card_is_verified_before_dispatch():
+    seen = []
+    body = _encrypted_body(
+        {
+            "type": "card.action.trigger",
+            "action": {"value": {"key": "value"}},
+        },
+        "encrypt-key",
+    )
+    handler = (
+        CardActionHandler.builder("encrypt-key", "verification-token")
+        .register(lambda card: seen.append(card))
+        .build()
+    )
+
+    resp = handler.do(
+        _request_bytes(
+            body,
+            _signed_headers(body, "verification-token", algorithm="sha1"),
+        )
+    )
+
+    assert resp.status_code == 200
+    assert resp.content == b'{"msg":"success"}'
+    assert len(seen) == 1
+
+
+def test_strict_card_invalid_signature_rejects_before_decrypt(monkeypatch):
+    recorder = InMemorySecurityAuditRecorder()
+    body = _encrypted_body({"type": "card.action.trigger"}, "encrypt-key")
+
+    def fail_decrypt(*_args, **_kwargs):
+        raise AssertionError("decrypt should not run")
+
+    monkeypatch.setattr(
+        "lark_channel.card.action_handler.AESCipher.decrypt_str",
+        fail_decrypt,
+    )
+    handler = CardActionHandler.builder(
+        "encrypt-key",
+        "verification-token",
+        security=SecurityConfig(mode="strict", audit_recorder=recorder),
+    ).build()
+
+    resp = handler.do(
+        _request_bytes(
+            body,
+            _signed_headers(body, "wrong-token", algorithm="sha1"),
+        )
+    )
+
+    assert resp.status_code == 500
+    assert json.loads(resp.content) == {"code": 500, "msg": "internal error"}
+    assert [event.reason for event in recorder.events] == [
+        REASON_CARD_SIGNATURE_INVALID
+    ]
+
+
+def test_strict_card_missing_signature_rejects_before_decrypt(monkeypatch):
+    recorder = InMemorySecurityAuditRecorder()
+    body = _encrypted_body({"type": "card.action.trigger"}, "encrypt-key")
+
+    def fail_decrypt(*_args, **_kwargs):
+        raise AssertionError("decrypt should not run")
+
+    monkeypatch.setattr(
+        "lark_channel.card.action_handler.AESCipher.decrypt_str",
+        fail_decrypt,
+    )
+    handler = CardActionHandler.builder(
+        "encrypt-key",
+        "verification-token",
+        security=SecurityConfig(mode="strict", audit_recorder=recorder),
+    ).build()
+
+    resp = handler.do(_request_bytes(body, {}))
+
+    assert resp.status_code == 500
+    assert json.loads(resp.content) == {"code": 500, "msg": "internal error"}
+    assert [event.reason for event in recorder.events] == [
+        REASON_CARD_SIGNATURE_MISSING
+    ]
+
+
+def test_strict_card_unsigned_encrypted_allow_records_allow_action():
+    seen = []
+    recorder = InMemorySecurityAuditRecorder()
+    body = _encrypted_body(
+        {
+            "type": "card.action.trigger",
+            "action": {"value": {"key": "value"}},
+        },
+        "encrypt-key",
+    )
+    handler = (
+        CardActionHandler.builder(
+            "encrypt-key",
+            "verification-token",
+            security=SecurityConfig(
+                mode="strict",
+                allow_unsigned_encrypted_webhook=True,
+                audit_recorder=recorder,
+            ),
+        )
+        .register(lambda card: seen.append(card))
+        .build()
+    )
+
+    resp = handler.do(_request_bytes(body, {}))
+
+    assert resp.status_code == 200
+    assert len(seen) == 1
+    assert [event.reason for event in recorder.events] == [
+        REASON_CARD_SIGNATURE_MISSING
+    ]
+    assert recorder.events[0].action == "allow"
+
+
+def test_strict_card_empty_verification_token_rejects_encrypted_before_decrypt(monkeypatch):
+    recorder = InMemorySecurityAuditRecorder()
+    body = _encrypted_body({"type": "card.action.trigger"}, "encrypt-key")
+
+    def fail_decrypt(*_args, **_kwargs):
+        raise AssertionError("decrypt should not run")
+
+    monkeypatch.setattr(
+        "lark_channel.card.action_handler.AESCipher.decrypt_str",
+        fail_decrypt,
+    )
+    handler = CardActionHandler.builder(
+        "encrypt-key",
+        "",
+        security=SecurityConfig(mode="strict", audit_recorder=recorder),
+    ).build()
+
+    resp = handler.do(_request_bytes(body, _signature_headers()))
+
+    assert resp.status_code == 500
+    assert json.loads(resp.content) == {"code": 500, "msg": "internal error"}
+    assert [event.reason for event in recorder.events] == [
+        REASON_CARD_SIGNATURE_MISSING
+    ]
+
+
+@pytest.mark.parametrize("mode", ["compat", "audit"])
+def test_unsigned_encrypted_card_legacy_flow_is_not_blocked(mode):
+    seen = []
+    recorder = InMemorySecurityAuditRecorder()
+    body = _encrypted_body(
+        {
+            "type": "card.action.trigger",
+            "action": {"value": {"key": "value"}},
+        },
+        "encrypt-key",
+    )
+    handler = (
+        CardActionHandler.builder(
+            "encrypt-key",
+            "verification-token",
+            security=SecurityConfig(mode=mode, audit_recorder=recorder),
+        )
+        .register(lambda card: seen.append(card))
+        .build()
+    )
+
+    resp = handler.do(_request_bytes(body, {}))
+
+    assert resp.status_code == 200
+    assert resp.content == b'{"msg":"success"}'
+    assert len(seen) == 1
+    assert [event.reason for event in recorder.events] == [
+        REASON_CARD_SIGNATURE_MISSING
+    ]
+
+
+def test_event_error_response_preserves_compat_bytes():
+    message = "ordinary error"
+
+    def raise_error(_event):
+        raise RuntimeError(message)
+
+    handler = (
+        EventDispatcherHandler.builder("", "verification-token")
+        .register_p2_customized_event("example.event", raise_error)
+        .build()
+    )
+
+    resp = handler.do(
+        _request(
+            {
+                "schema": "2.0",
+                "header": {
+                    "event_type": "example.event",
+                    "token": "verification-token",
+                },
+                "event": {"value": "ok"},
+            }
+        )
+    )
+
+    assert resp.status_code == 500
+    assert resp.content == b'{"msg":"ordinary error"}'
+
+
+def test_event_error_response_preserves_audit_bytes():
+    message = "ordinary error"
+
+    def raise_error(_event):
+        raise RuntimeError(message)
+
+    handler = (
+        EventDispatcherHandler.builder(
+            "",
+            "verification-token",
+            security=SecurityConfig(mode="audit"),
+        )
+        .register_p2_customized_event("example.event", raise_error)
+        .build()
+    )
+
+    resp = handler.do(
+        _request(
+            {
+                "schema": "2.0",
+                "header": {
+                    "event_type": "example.event",
+                    "token": "verification-token",
+                },
+                "event": {"value": "ok"},
+            }
+        )
+    )
+
+    assert resp.status_code == 500
+    assert resp.content == b'{"msg":"ordinary error"}'
+
+
+def test_event_strict_error_response_hides_exception_detail():
+    message = "internal secret detail"
+
+    def raise_error(_event):
+        raise RuntimeError(message)
+
+    handler = (
+        EventDispatcherHandler.builder(
+            "",
+            "verification-token",
+            security=SecurityConfig(mode="strict"),
+        )
+        .register_p2_customized_event("example.event", raise_error)
+        .build()
+    )
+
+    resp = handler.do(
+        _request(
+            {
+                "schema": "2.0",
+                "header": {
+                    "event_type": "example.event",
+                    "token": "verification-token",
+                },
+                "event": {"value": "ok"},
+            }
+        )
+    )
+
+    assert resp.status_code == 500
+    assert json.loads(resp.content) == {"code": 500, "msg": "internal error"}
+    assert message.encode("utf-8") not in resp.content
+
+
+@pytest.mark.asyncio
+async def test_feishu_channel_strict_error_response_hides_exception_detail():
+    ch = FeishuChannel(
+        app_id="cli_x",
+        app_secret="x",
+        verification_token="vtok",
+        transport="webhook",
+        security=SecurityConfig(mode="strict"),
+    )
+    ch.start()
+    try:
+        body = json.dumps(
+            {
+                "schema": "2.0",
+                "header": {
+                    "event_type": "unknown.event",
+                    "token": "vtok",
+                },
+                "event": {"value": "ok"},
+            }
+        ).encode("utf-8")
+
+        status, response_body = await ch.handle_webhook_request(headers={}, body=body)
+
+        assert status == 500
+        assert json.loads(response_body) == {"code": 500, "msg": "internal error"}
+        assert b"unknown.event" not in response_body
+    finally:
+        await ch.stop_background()
+        ch.stop()
+
+
+def test_card_error_response_preserves_compat_bytes():
+    message = "ordinary error"
+
+    def raise_error(_card):
+        raise RuntimeError(message)
+
+    handler = CardActionHandler.builder("", "").register(raise_error).build()
+
+    resp = handler.do(
+        _request(
+            {
+                "type": "card.action.trigger",
+                "action": {"value": {"key": "value"}},
+            }
+        )
+    )
+
+    assert resp.status_code == 500
+    assert resp.content == b'{"msg":"ordinary error"}'
+
+
+def test_card_error_response_preserves_audit_bytes():
+    message = "ordinary error"
+
+    def raise_error(_card):
+        raise RuntimeError(message)
+
+    handler = (
+        CardActionHandler.builder("", "", security=SecurityConfig(mode="audit"))
+        .register(raise_error)
+        .build()
+    )
+
+    resp = handler.do(
+        _request(
+            {
+                "type": "card.action.trigger",
+                "action": {"value": {"key": "value"}},
+            }
+        )
+    )
+
+    assert resp.status_code == 500
+    assert resp.content == b'{"msg":"ordinary error"}'
+
+
+def test_card_strict_error_response_hides_exception_detail():
+    message = "internal secret detail"
+
+    def raise_error(_card):
+        raise RuntimeError(message)
+
+    handler = (
+        CardActionHandler.builder("", "", security=SecurityConfig(mode="strict"))
+        .register(raise_error)
+        .build()
+    )
+
+    resp = handler.do(
+        _request(
+            {
+                "type": "card.action.trigger",
+                "action": {"value": {"key": "value"}},
+            }
+        )
+    )
+
+    assert resp.status_code == 500
+    assert json.loads(resp.content) == {"code": 500, "msg": "internal error"}
+    assert message.encode("utf-8") not in resp.content
diff --git a/lark_channel/channel/tests/test_identity.py b/lark_channel/channel/tests/test_identity.py
new file mode 100644
index 0000000..7266c45
--- /dev/null
+++ b/lark_channel/channel/tests/test_identity.py
@@ -0,0 +1,55 @@
+"""Identity resolver + name cache tests."""
+
+import pytest
+
+from lark_channel.channel.config import NameCacheConfig
+from lark_channel.channel.identity import IdentityResolver, NameCache
+from lark_channel.channel.types import Identity
+
+
+def test_name_cache_ttl_and_lru():
+    c = NameCache(NameCacheConfig(max_size=2, ttl_seconds=3600))
+    c.put("a", "A")
+    c.put("b", "B")
+    assert c.get("a") == "A"
+    c.put("c", "C")
+    # "b" should be evicted; "a" was recently touched via get
+    assert c.get("b") is None
+    assert c.get("c") == "C"
+
+
+@pytest.mark.asyncio
+async def test_resolver_batches_missing():
+    calls = []
+
+    def lookup(ids):
+        calls.append(list(ids))
+        return {i: Identity(open_id=i, display_name=f"name_{i}") for i in ids}
+
+    r = IdentityResolver(lookup=lookup)
+    out = await r.resolve_names(["a", "b"])
+    assert out == {"a": "name_a", "b": "name_b"}
+    # Second call uses cache for both
+    out2 = await r.resolve_names(["a", "b"])
+    assert out2 == {"a": "name_a", "b": "name_b"}
+    assert len(calls) == 1  # no second lookup
+
+
+@pytest.mark.asyncio
+async def test_resolver_tolerates_lookup_error():
+    def lookup(ids):
+        raise RuntimeError("boom")
+
+    r = IdentityResolver(lookup=lookup)
+    out = await r.resolve_names(["a"])
+    assert out == {}
+
+
+@pytest.mark.asyncio
+async def test_resolve_single_returns_identity():
+    def lookup(ids):
+        return {i: Identity(open_id=i, display_name="N") for i in ids}
+
+    r = IdentityResolver(lookup=lookup)
+    ident = await r.resolve("a")
+    assert ident.open_id == "a" and ident.display_name == "N"
diff --git a/lark_channel/channel/tests/test_inbound_safety_routing.py b/lark_channel/channel/tests/test_inbound_safety_routing.py
new file mode 100644
index 0000000..96b16f2
--- /dev/null
+++ b/lark_channel/channel/tests/test_inbound_safety_routing.py
@@ -0,0 +1,322 @@
+"""Every inbound handler must route through the right ``SafetyPipeline`` tier:
+
+    * cardAction  → ``push_action`` (tier 2, dedup + lock + queue by chatId)
+    * reaction    → ``push_light``  (tier 3, dedup only)
+    * comment     → ``push_action`` (tier 2, dedup + lock + queue by fileToken)
+
+This guards against bypassing the safety tiers and accidentally allowing
+redelivered events to double-fire user handlers.
+"""
+
+from types import SimpleNamespace
+from unittest.mock import AsyncMock
+
+import pytest
+
+from lark_channel.channel import FeishuChannel
+from lark_channel.channel.config import ChannelConfig, InboundConfig
+
+
+def _client(reaction_notifications: str = "all") -> FeishuChannel:
+    # Default inbound.reaction_notifications is "own" — i.e. the channel
+    # ignores reactions on messages it didn't send. For routing assertions
+    # we want every reaction to fall through to the safety pipeline, so
+    # override to "all".
+    c = FeishuChannel(
+        app_id="cli_test",
+        app_secret="sec",
+        config=ChannelConfig(
+            inbound=InboundConfig(reaction_notifications=reaction_notifications),
+        ),
+    )
+    c._ensure_bg_loop()
+    return c
+
+
+def _installed_safety(channel: FeishuChannel):
+    """Install AsyncMocks for push_action / push_light on a channel that
+    hasn't been ``connect()``-ed, so the handlers see a non-None safety
+    and take the safe path instead of the fallback direct-invoke."""
+    safety = SimpleNamespace(
+        push_action=AsyncMock(),
+        push_light=AsyncMock(),
+    )
+    channel._safety = safety  # type: ignore[assignment]
+    return safety
+
+
+# ---------------------------------------------------------------------------
+# cardAction → push_action
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_card_action_routes_through_push_action():
+    c = _client()
+    safety = _installed_safety(c)
+
+    action = SimpleNamespace(tag="button", value={"name": "confirm", "id": 7})
+    context = SimpleNamespace(open_message_id="om_1", open_chat_id="oc_1")
+    operator = SimpleNamespace(open_id="ou_u")
+    event = SimpleNamespace(action=action, context=context, operator=operator)
+    data = SimpleNamespace(event=event)
+
+    await c._handle_interaction_event(data)
+
+    assert safety.push_action.await_count == 1
+    event_id, scope, _handler = safety.push_action.await_args.args
+    assert event_id.startswith("card:om_1:ou_u:")
+    # stable action identity includes tag and JSON-sorted value
+    assert event_id.endswith('button:{"id": 7, "name": "confirm"}')
+    assert '"id": 7' in event_id and '"name": "confirm"' in event_id
+    assert scope == "oc_1"
+    # tier 3 must not be touched
+    assert safety.push_light.await_count == 0
+
+
+@pytest.mark.asyncio
+async def test_card_action_event_id_includes_form_fields():
+    c = _client()
+    safety = _installed_safety(c)
+
+    action = SimpleNamespace(
+        tag="form",
+        value={"name": "submit"},
+        form_value={"field": "first"},
+        input_value="typed",
+        options=["a", "b"],
+        checked=True,
+    )
+    context = SimpleNamespace(open_message_id="om_1", open_chat_id="oc_1")
+    operator = SimpleNamespace(open_id="ou_u")
+    event = SimpleNamespace(action=action, context=context, operator=operator)
+    data = SimpleNamespace(event=event)
+
+    await c._handle_interaction_event(data)
+
+    event_id, _scope, _handler = safety.push_action.await_args.args
+    assert '"form_value": {"field": "first"}' in event_id
+    assert '"input_value": "typed"' in event_id
+    assert '"options": ["a", "b"]' in event_id
+    assert '"checked": true' in event_id
+
+
+@pytest.mark.asyncio
+async def test_card_action_event_id_survives_unserializable_form_field():
+    class BadRepr:
+        def __repr__(self):
+            raise RuntimeError("repr failed")
+
+    c = _client()
+    safety = _installed_safety(c)
+
+    action = SimpleNamespace(
+        tag="form",
+        value={"name": "submit"},
+        form_value={"bad": BadRepr()},
+    )
+    context = SimpleNamespace(open_message_id="om_1", open_chat_id="oc_1")
+    operator = SimpleNamespace(open_id="ou_u")
+    event = SimpleNamespace(action=action, context=context, operator=operator)
+    data = SimpleNamespace(event=event)
+
+    await c._handle_interaction_event(data)
+
+    assert safety.push_action.await_count == 1
+    event_id, _scope, _handler = safety.push_action.await_args.args
+    assert '"form_value": {"bad": "<unserializable:BadRepr>"}' in event_id
+
+
+@pytest.mark.asyncio
+async def test_card_action_event_id_with_form_fields_survives_unserializable_value():
+    class BadRepr:
+        def __repr__(self):
+            raise RuntimeError("repr failed")
+
+    c = _client()
+    safety = _installed_safety(c)
+
+    action = SimpleNamespace(
+        tag="button",
+        value={"bad": BadRepr()},
+        form_value={"field": "value"},
+    )
+    context = SimpleNamespace(open_message_id="om_1", open_chat_id="oc_1")
+    operator = SimpleNamespace(open_id="ou_u")
+    event = SimpleNamespace(action=action, context=context, operator=operator)
+    data = SimpleNamespace(event=event)
+
+    await c._handle_interaction_event(data)
+
+    assert safety.push_action.await_count == 1
+    event_id, _scope, _handler = safety.push_action.await_args.args
+    assert '"bad": "<unserializable:BadRepr>"' in event_id
+
+
+@pytest.mark.asyncio
+async def test_card_action_without_form_fields_keeps_legacy_value_repr():
+    class ReprOnly:
+        def __repr__(self):
+            return "<repr-only>"
+
+    c = _client()
+    safety = _installed_safety(c)
+
+    action = SimpleNamespace(tag="button", value=ReprOnly())
+    context = SimpleNamespace(open_message_id="om_1", open_chat_id="oc_1")
+    operator = SimpleNamespace(open_id="ou_u")
+    event = SimpleNamespace(action=action, context=context, operator=operator)
+    data = SimpleNamespace(event=event)
+
+    await c._handle_interaction_event(data)
+
+    assert safety.push_action.await_count == 1
+    event_id, _scope, _handler = safety.push_action.await_args.args
+    assert event_id.endswith("button:<repr-only>")
+
+
+@pytest.mark.asyncio
+async def test_card_action_event_id_survives_cyclic_form_field():
+    c = _client()
+    safety = _installed_safety(c)
+    cyclic = {}
+    cyclic["self"] = cyclic
+
+    action = SimpleNamespace(
+        tag="form",
+        value={"name": "submit"},
+        form_value=cyclic,
+    )
+    context = SimpleNamespace(open_message_id="om_1", open_chat_id="oc_1")
+    operator = SimpleNamespace(open_id="ou_u")
+    event = SimpleNamespace(action=action, context=context, operator=operator)
+    data = SimpleNamespace(event=event)
+
+    await c._handle_interaction_event(data)
+
+    assert safety.push_action.await_count == 1
+    event_id, _scope, _handler = safety.push_action.await_args.args
+    assert '"self": "<cycle>"' in event_id
+
+
+@pytest.mark.asyncio
+async def test_card_action_fallback_without_safety_still_invokes():
+    """If the pipeline hasn't been built yet (early event, unit test
+    bypassing connect), the handler must still fire — just without
+    dedup/lock protection."""
+    # Fresh channel, do NOT call _ensure_bg_loop → _safety stays None.
+    c = FeishuChannel(app_id="cli_test", app_secret="sec")
+    assert c._safety is None
+    calls: list = []
+
+    def _on(evt):
+        calls.append(evt)
+
+    c.on("cardAction", _on)
+
+    action = SimpleNamespace(tag="button", value=None)
+    context = SimpleNamespace(open_message_id="om_x", open_chat_id="oc_x")
+    operator = SimpleNamespace(open_id="ou_x")
+    event = SimpleNamespace(action=action, context=context, operator=operator)
+    data = SimpleNamespace(event=event)
+
+    await c._handle_interaction_event(data)
+    assert len(calls) == 1
+    assert calls[0].message_id == "om_x"
+
+
+# ---------------------------------------------------------------------------
+# reaction → push_light
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_reaction_added_routes_through_push_light():
+    c = _client()
+    safety = _installed_safety(c)
+
+    data = SimpleNamespace(event=SimpleNamespace(
+        user_id=SimpleNamespace(open_id="ou_r"),
+        message_id="om_m",
+        reaction_type=SimpleNamespace(emoji_type="THUMBSUP"),
+        action_time="1777000000",
+    ))
+
+    await c._handle_reaction_event(data, action="create")
+
+    assert safety.push_light.await_count == 1
+    event_id, _handler = safety.push_light.await_args.args
+    assert event_id == "reaction:om_m:ou_r:THUMBSUP:added"
+    assert safety.push_action.await_count == 0
+
+
+@pytest.mark.asyncio
+async def test_reaction_removed_event_id_distinguishes_direction():
+    """Same message + user + emoji but add vs remove must dedup separately,
+    otherwise an add immediately followed by a remove would drop one."""
+    c = _client()
+    safety = _installed_safety(c)
+
+    data = SimpleNamespace(event=SimpleNamespace(
+        user_id=SimpleNamespace(open_id="ou_r"),
+        message_id="om_m",
+        reaction_type=SimpleNamespace(emoji_type="THUMBSUP"),
+        action_time=None,
+    ))
+
+    await c._handle_reaction_event(data, action="create")
+    await c._handle_reaction_event(data, action="delete")
+
+    calls = [a.args[0] for a in safety.push_light.await_args_list]
+    assert calls == [
+        "reaction:om_m:ou_r:THUMBSUP:added",
+        "reaction:om_m:ou_r:THUMBSUP:removed",
+    ]
+
+
+# ---------------------------------------------------------------------------
+# comment → push_action
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_comment_routes_through_push_action_scoped_by_file_token():
+    c = _client()
+    safety = _installed_safety(c)
+
+    # Realistic ``drive.notice.comment_add_v1`` wire shape.
+    data = SimpleNamespace(event={
+        "file_token": "doc_abc",
+        "file_type": "docx",
+        "comment_id": "cmt_99",
+        "is_mentioned": True,
+        "create_time": "1700000000000",
+        "notice_meta": {
+            "from_user_id": {"open_id": "ou_o"},
+            "is_mentioned": True,
+            "timestamp": "1700000000000",
+        },
+    })
+
+    await c._handle_comment_event(data)
+
+    assert safety.push_action.await_count == 1
+    event_id, scope, _handler = safety.push_action.await_args.args
+    assert event_id == "comment:doc_abc:cmt_99"
+    assert scope == "doc_abc"
+    assert safety.push_light.await_count == 0
+
+
+@pytest.mark.asyncio
+async def test_comment_without_file_token_is_dropped_before_safety():
+    """normalize_comment returns None for malformed payloads; safety must
+    not be invoked with empty event_id / scope (which would collide
+    across unrelated null events and cause cross-event dedup)."""
+    c = _client()
+    safety = _installed_safety(c)
+
+    # Missing file_token → normalize_comment returns None
+    data = SimpleNamespace(event={"comment_id": "cmt_x"})
+    await c._handle_comment_event(data)
+
+    assert safety.push_action.await_count == 0
diff --git a/lark_channel/channel/tests/test_interactive.py b/lark_channel/channel/tests/test_interactive.py
new file mode 100644
index 0000000..49ca781
--- /dev/null
+++ b/lark_channel/channel/tests/test_interactive.py
@@ -0,0 +1,155 @@
+"""Unit tests for inbound/interactive.py (card refetch + v1/v2 detection)."""
+
+import json
+
+import pytest
+
+from lark_channel.channel.normalize.interactive import (
+    _detect_version,
+    _extract_card_json,
+    _parse_body_content,
+    fetch_interactive,
+)
+from lark_channel.channel.types import InteractiveContent
+
+
+# ---- Version detection --------------------------------------------------
+
+
+def test_detect_v2_by_schema():
+    assert _detect_version({"schema": "2.0", "body": {}}) == "v2"
+
+
+def test_detect_v2_by_body_only():
+    assert _detect_version({"body": {"elements": []}}) == "v2"
+
+
+def test_detect_v1_by_elements():
+    assert _detect_version({"elements": [], "config": {}}) == "v1"
+
+
+def test_detect_v1_by_i18n_elements():
+    assert _detect_version({"i18n_elements": {}}) == "v1"
+
+
+def test_detect_unknown_for_empty():
+    assert _detect_version({}) == "unknown"
+
+
+def test_detect_handles_non_dict():
+    assert _detect_version("nonsense") == "unknown"  # type: ignore[arg-type]
+
+
+def test_detect_unwraps_card_wrapper():
+    """Some payloads wrap under a `card` key."""
+    assert _detect_version({"card": {"schema": "2.0", "body": {}}}) == "v2"
+
+
+# ---- Content extraction -------------------------------------------------
+
+
+def test_parse_body_content_from_string():
+    body = {"content": json.dumps({"schema": "2.0", "body": {}})}
+    assert _parse_body_content(body) == {"schema": "2.0", "body": {}}
+
+
+def test_parse_body_content_from_dict():
+    direct = {"schema": "2.0", "body": {}}
+    body = {"content": direct}
+    assert _parse_body_content(body) == direct
+
+
+def test_parse_body_content_invalid_string_returns_none():
+    assert _parse_body_content({"content": "{{bad json"}) is None
+
+
+def test_parse_body_content_missing_returns_none():
+    assert _parse_body_content({}) is None
+
+
+def test_extract_card_json_from_items_array():
+    payload = {
+        "data": {
+            "items": [
+                {"body": {"content": json.dumps({"schema": "2.0", "body": {}})}},
+            ],
+        },
+    }
+    assert _extract_card_json(payload) == {"schema": "2.0", "body": {}}
+
+
+def test_extract_card_json_empty_payload_returns_none():
+    assert _extract_card_json({}) is None
+    assert _extract_card_json({"data": {"items": []}}) is None
+
+
+def test_extract_card_json_from_flat_data():
+    payload = {"data": {"body": {"content": json.dumps({"schema": "2.0", "body": {}})}}}
+    assert _extract_card_json(payload) == {"schema": "2.0", "body": {}}
+
+
+# ---- fetch_interactive -------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_fetch_interactive_success_v2():
+    async def fetch(mid):
+        return {
+            "data": {"items": [{"body": {"content": json.dumps({
+                "schema": "2.0",
+                "body": {"elements": [{"tag": "markdown", "content": "hello"}]},
+            })}}]},
+        }
+
+    result = await fetch_interactive("om_1", fetch)
+    assert isinstance(result, InteractiveContent)
+    assert result.card_version == "v2"
+
+
+@pytest.mark.asyncio
+async def test_fetch_interactive_success_v1():
+    async def fetch(mid):
+        return {
+            "data": {"items": [{"body": {"content": json.dumps({
+                "elements": [{"tag": "markdown", "content": "legacy"}],
+                "config": {},
+            })}}]},
+        }
+
+    result = await fetch_interactive("om_1", fetch)
+    assert result is not None
+    assert result.card_version == "v1"
+
+
+@pytest.mark.asyncio
+async def test_fetch_interactive_sync_fetch_also_accepted():
+    """Injected fetcher may return a plain value (not awaitable)."""
+    def fetch(mid):
+        return {"data": {"items": [{"body": {"content": json.dumps({"schema": "2.0", "body": {}})}}]}}
+
+    result = await fetch_interactive("om_1", fetch)
+    assert result and result.card_version == "v2"
+
+
+@pytest.mark.asyncio
+async def test_fetch_interactive_fetcher_raises_returns_none():
+    async def fetch(mid):
+        raise RuntimeError("network")
+
+    assert await fetch_interactive("om_1", fetch) is None
+
+
+@pytest.mark.asyncio
+async def test_fetch_interactive_empty_response_returns_none():
+    async def fetch(mid):
+        return None
+
+    assert await fetch_interactive("om_1", fetch) is None
+
+
+@pytest.mark.asyncio
+async def test_fetch_interactive_malformed_json_returns_none():
+    async def fetch(mid):
+        return {"data": {"items": [{"body": {"content": "{{{"}}]}}
+
+    assert await fetch_interactive("om_1", fetch) is None
diff --git a/lark_channel/channel/tests/test_is_ready.py b/lark_channel/channel/tests/test_is_ready.py
new file mode 100644
index 0000000..7448481
--- /dev/null
+++ b/lark_channel/channel/tests/test_is_ready.py
@@ -0,0 +1,37 @@
+"""is_ready / wait_ready behavior.
+
+These tests poke FeishuChannel at the API surface, not the WS layer. They
+flip the readiness event manually to confirm the property and the await
+behavior, since spinning a real WS connection in unit tests is unreasonable.
+"""
+
+import asyncio
+import pytest
+
+from lark_channel.channel import FeishuChannel
+
+
+def test_is_ready_false_before_start():
+    ch = FeishuChannel(app_id="cli_x", app_secret="x")
+    assert ch.is_ready is False
+
+
+@pytest.mark.asyncio
+async def test_wait_ready_resolves_when_event_set():
+    ch = FeishuChannel(app_id="cli_x", app_secret="x")
+    loop = asyncio.get_running_loop()
+
+    async def flip_after():
+        await asyncio.sleep(0.05)
+        ch._mark_ready()  # internal API, used in tests
+
+    loop.create_task(flip_after())
+    await asyncio.wait_for(ch.wait_ready(), timeout=1.0)
+    assert ch.is_ready is True
+
+
+@pytest.mark.asyncio
+async def test_wait_ready_timeout_raises():
+    ch = FeishuChannel(app_id="cli_x", app_secret="x")
+    with pytest.raises(asyncio.TimeoutError):
+        await ch.wait_ready(timeout=0.05)
diff --git a/lark_channel/channel/tests/test_log_redaction.py b/lark_channel/channel/tests/test_log_redaction.py
new file mode 100644
index 0000000..9e719be
--- /dev/null
+++ b/lark_channel/channel/tests/test_log_redaction.py
@@ -0,0 +1,362 @@
+import json
+import logging
+from types import SimpleNamespace
+
+import pytest
+from requests_toolbelt import MultipartEncoder
+
+from lark_channel.card.action_handler import CardActionHandler
+from lark_channel.channel import SecurityConfig
+from lark_channel.core.const import AUTHORIZATION
+from lark_channel.core.enum import AccessTokenType, HttpMethod
+from lark_channel.core.http.transport import Transport
+from lark_channel.core.model import BaseRequest, Config, RawRequest, RequestOption
+from lark_channel.event.dispatcher_handler import EventDispatcherHandler
+from lark_channel.ws import client as ws_client
+from lark_channel.ws.const import (
+    HEADER_MESSAGE_ID,
+    HEADER_SEQ,
+    HEADER_SUM,
+    HEADER_TRACE_ID,
+    HEADER_TYPE,
+)
+from lark_channel.ws.enum import FrameType, MessageType
+from lark_channel.ws.pb.pbbp2_pb2 import Frame
+
+
+def test_transport_debug_log_redacts_authorization_and_secret(caplog, monkeypatch):
+    captured = {}
+
+    def fake_request(method, url, **kwargs):
+        captured["headers"] = kwargs["headers"]
+        return SimpleNamespace(status_code=200, headers={}, content=b"{}")
+
+    monkeypatch.setattr("lark_channel.core.http.transport.requests.request", fake_request)
+
+    conf = Config()
+    conf.domain = "https://open.feishu.cn"
+    req = BaseRequest()
+    req.http_method = HttpMethod.POST
+    req.uri = "/open-apis/auth/v3/tenant_access_token/internal"
+    req.token_types = {AccessTokenType.TENANT}
+    req.body = {
+        "app_id": "cli_x",
+        "app_secret": "app_secret_value",
+        "refresh_token": "refresh_token_value",
+    }
+    option = RequestOption()
+    option.tenant_access_token = "tenant_token_value"
+
+    with caplog.at_level(logging.DEBUG, logger="Lark"):
+        Transport.execute(conf, req, option)
+
+    assert captured["headers"][AUTHORIZATION] == "Bearer tenant_token_value"
+    assert "tenant_token_value" not in caplog.text
+    assert "app_secret_value" not in caplog.text
+    assert "refresh_token_value" not in caplog.text
+    assert "Bearer ***" in caplog.text
+
+
+def test_transport_debug_log_redacts_common_security_headers_and_camel_tokens(caplog, monkeypatch):
+    def fake_request(method, url, **kwargs):
+        return SimpleNamespace(status_code=200, headers={}, content=b"{}")
+
+    monkeypatch.setattr("lark_channel.core.http.transport.requests.request", fake_request)
+
+    conf = Config()
+    conf.domain = "https://open.feishu.cn"
+    req = BaseRequest()
+    req.http_method = HttpMethod.POST
+    req.uri = "/open-apis/example"
+    req.headers = {
+        "Cookie": "sessionid=cookie-secret-value",
+        "X-Api-Key": "api-key-secret-value",
+    }
+    req.body = {
+        "verificationToken": "verification-token-secret",
+        "accessToken": "access-token-secret",
+        "encrypt_key": "encrypt-key-secret",
+        "private_key": "private-key-secret",
+        "safe": "visible",
+    }
+
+    with caplog.at_level(logging.DEBUG, logger="Lark"):
+        Transport.execute(conf, req, RequestOption())
+
+    for secret in (
+        "cookie-secret-value",
+        "api-key-secret-value",
+        "verification-token-secret",
+        "access-token-secret",
+        "encrypt-key-secret",
+        "private-key-secret",
+    ):
+        assert secret not in caplog.text
+    assert "visible" in caplog.text
+
+
+def test_transport_debug_log_redacts_sensitive_query_params(caplog, monkeypatch):
+    def fake_request(method, url, **kwargs):
+        return SimpleNamespace(status_code=200, headers={}, content=b"{}")
+
+    monkeypatch.setattr("lark_channel.core.http.transport.requests.request", fake_request)
+
+    conf = Config()
+    conf.domain = "https://open.feishu.cn"
+    req = BaseRequest()
+    req.http_method = HttpMethod.GET
+    req.uri = "/open-apis/example"
+    req.queries = [
+        ("access_token", "query_token_value"),
+        ("secret", "query_secret_value"),
+        ("file_token", "doc_1"),
+    ]
+
+    with caplog.at_level(logging.DEBUG, logger="Lark"):
+        Transport.execute(conf, req, RequestOption())
+
+    assert "query_token_value" not in caplog.text
+    assert "query_secret_value" not in caplog.text
+    assert "doc_1" in caplog.text
+
+
+def test_transport_log_handles_multipart_body_at_default_level(monkeypatch):
+    captured = {}
+
+    def fake_request(method, url, **kwargs):
+        captured["data"] = kwargs["data"]
+        return SimpleNamespace(status_code=200, headers={}, content=b"{}")
+
+    monkeypatch.setattr("lark_channel.core.http.transport.requests.request", fake_request)
+
+    conf = Config()
+    conf.domain = "https://open.feishu.cn"
+    req = BaseRequest()
+    req.http_method = HttpMethod.POST
+    req.uri = "/open-apis/im/v1/images"
+    encoder = MultipartEncoder(
+        fields={
+            "image_type": "message",
+            "image": ("secret.png", b"secret-upload-content", "image/png"),
+        }
+    )
+    req.body = encoder
+
+    Transport.execute(conf, req, RequestOption())
+
+    assert captured["data"] is encoder
+
+
+def test_transport_debug_log_handles_multipart_body_without_leaking_contents(caplog, monkeypatch):
+    captured = {}
+
+    def fake_request(method, url, **kwargs):
+        captured["data"] = kwargs["data"]
+        return SimpleNamespace(status_code=200, headers={}, content=b"{}")
+
+    monkeypatch.setattr("lark_channel.core.http.transport.requests.request", fake_request)
+
+    conf = Config()
+    conf.domain = "https://open.feishu.cn"
+    req = BaseRequest()
+    req.http_method = HttpMethod.POST
+    req.uri = "/open-apis/im/v1/files"
+    encoder = MultipartEncoder(
+        fields={
+            "file_type": "stream",
+            "file": ("secret.txt", b"secret-upload-content", "text/plain"),
+        }
+    )
+    req.body = encoder
+
+    with caplog.at_level(logging.DEBUG, logger="Lark"):
+        Transport.execute(conf, req, RequestOption())
+
+    assert captured["data"] is encoder
+    assert "secret-upload-content" not in caplog.text
+    assert "secret.txt" not in caplog.text
+    assert "<MultipartEncoder>" in caplog.text
+
+
+@pytest.mark.asyncio
+async def test_async_transport_debug_log_redacts_json_multipart_file_bytes(caplog, monkeypatch):
+    captured = {}
+
+    class FakeAsyncClient:
+        def __init__(self, **kwargs):
+            pass
+
+        async def __aenter__(self):
+            return self
+
+        async def __aexit__(self, exc_type, exc, tb):
+            return False
+
+        async def request(self, *args, **kwargs):
+            captured["files"] = kwargs["files"]
+            return SimpleNamespace(status_code=200, headers={}, content=b"{}")
+
+    monkeypatch.setattr("lark_channel.core.http.transport.httpx.AsyncClient", FakeAsyncClient)
+
+    conf = Config()
+    conf.domain = "https://open.feishu.cn"
+    req = BaseRequest()
+    req.http_method = HttpMethod.POST
+    req.uri = "/open-apis/im/v1/files"
+    req.files = {
+        "file": (
+            "report.json",
+            b'{"api_key":"plain-secret","note":"file-body"}',
+            "application/json",
+        )
+    }
+
+    with caplog.at_level(logging.DEBUG, logger="Lark"):
+        await Transport.aexecute(conf, req, RequestOption())
+
+    assert captured["files"] is req.files
+    assert "plain-secret" not in caplog.text
+    assert "file-body" not in caplog.text
+    assert "report.json" not in caplog.text
+    assert "<file upload>" in caplog.text
+
+
+def test_event_debug_log_redacts_plain_verification_token(caplog):
+    req = RawRequest()
+    req.uri = "/callback"
+    req.headers = {}
+    req.body = json.dumps(
+        {
+            "type": "url_verification",
+            "challenge": "challenge-code",
+            "token": "verification-token-value",
+        }
+    ).encode("utf-8")
+    handler = EventDispatcherHandler.builder("", "verification-token-value").build()
+
+    with caplog.at_level(logging.DEBUG, logger="Lark"):
+        handler.do(req)
+
+    assert "verification-token-value" not in caplog.text
+
+
+def test_event_strict_error_log_redacts_exception_detail(caplog):
+    message = "app_secret=event-secret-value"
+
+    def raise_error(_event):
+        raise RuntimeError(message)
+
+    handler = (
+        EventDispatcherHandler.builder(
+            "",
+            "verification-token",
+            security=SecurityConfig(mode="strict"),
+        )
+        .register_p2_customized_event("example.event", raise_error)
+        .build()
+    )
+    req = RawRequest()
+    req.uri = "/callback"
+    req.headers = {}
+    req.body = json.dumps(
+        {
+            "schema": "2.0",
+            "header": {
+                "event_type": "example.event",
+                "token": "verification-token",
+            },
+            "event": {"value": "ok"},
+        }
+    ).encode("utf-8")
+
+    with caplog.at_level(logging.ERROR, logger="Lark"):
+        handler.do(req)
+
+    assert "event-secret-value" not in caplog.text
+    assert "app_secret" in caplog.text
+
+
+def test_card_debug_log_redacts_plain_verification_token(caplog):
+    req = RawRequest()
+    req.uri = "/callback"
+    req.headers = {}
+    req.body = json.dumps(
+        {
+            "type": "url_verification",
+            "challenge": "challenge-code",
+            "token": "verification-token-value",
+        }
+    ).encode("utf-8")
+    handler = CardActionHandler.builder("", "verification-token-value").build()
+
+    with caplog.at_level(logging.DEBUG, logger="Lark"):
+        handler.do(req)
+
+    assert "verification-token-value" not in caplog.text
+
+
+def test_card_strict_error_log_redacts_exception_detail(caplog):
+    message = "app_secret=card-secret-value"
+
+    def raise_error(_card):
+        raise RuntimeError(message)
+
+    handler = (
+        CardActionHandler.builder(
+            "",
+            "",
+            security=SecurityConfig(mode="strict"),
+        )
+        .register(raise_error)
+        .build()
+    )
+    req = RawRequest()
+    req.uri = "/callback"
+    req.headers = {}
+    req.body = json.dumps(
+        {
+            "type": "card.action.trigger",
+            "action": {"value": {"key": "value"}},
+        }
+    ).encode("utf-8")
+
+    with caplog.at_level(logging.ERROR, logger="Lark"):
+        handler.do(req)
+
+    assert "card-secret-value" not in caplog.text
+    assert "app_secret" in caplog.text
+
+
+@pytest.mark.asyncio
+async def test_ws_debug_log_does_not_emit_event_payload(caplog, monkeypatch):
+    client = ws_client.Client(app_id="cli_x", app_secret="s")
+    client._service_id = "42"
+    client._event_handler = SimpleNamespace(_do_without_validation=lambda payload: None)
+
+    async def fake_write_message(data):
+        return None
+
+    monkeypatch.setattr(client, "_write_message", fake_write_message)
+
+    frame = Frame()
+    frame.method = FrameType.DATA.value
+    frame.service = 42
+    frame.SeqID = 1
+    frame.LogID = 1
+    frame.payload = b'{"event":{"text":"payload-secret-value"}}'
+    for key, value in (
+        (HEADER_MESSAGE_ID, "msg_1"),
+        (HEADER_TRACE_ID, "trace_1"),
+        (HEADER_SUM, "1"),
+        (HEADER_SEQ, "0"),
+        (HEADER_TYPE, MessageType.EVENT.value),
+    ):
+        header = frame.headers.add()
+        header.key = key
+        header.value = value
+
+    with caplog.at_level(logging.DEBUG, logger="Lark"):
+        await client._handle_data_frame(frame)
+
+    assert "payload-secret-value" not in caplog.text
+    assert "payload_len" in caplog.text
diff --git a/lark_channel/channel/tests/test_long_markdown_chunking.py b/lark_channel/channel/tests/test_long_markdown_chunking.py
new file mode 100644
index 0000000..5a820b3
--- /dev/null
+++ b/lark_channel/channel/tests/test_long_markdown_chunking.py
@@ -0,0 +1,67 @@
+"""Outbound regression probes for long markdown chunking.
+
+These tests pin the seams that test fakes patch (``send_driver``-returned
+bound methods) so that future refactors do not silently break the patching
+contract. The test suite intentionally only covers the seam the sender
+actually calls; patches against ad-hoc instance attributes will not flow.
+"""
+
+from typing import Any, Dict, List
+
+import pytest
+
+from lark_channel.channel.config import OutboundConfig
+from lark_channel.channel.outbound.sender import OutboundSender, SendDriver
+from lark_channel.channel.types import OutboundPost, SendResult
+
+
+def _driver():
+    calls: List[Dict[str, Any]] = []
+
+    async def create_message(**kwargs):
+        calls.append({"op": "create", **kwargs})
+        # Give each call a distinct message_id so a hypothetical chunked
+        # send would yield a visible list of ids.
+        return {
+            "code": 0,
+            "data": {"message_id": f"om_chunk_{len(calls)}"},
+        }
+
+    async def reply_message(**kwargs):
+        calls.append({"op": "reply", **kwargs})
+        return {"code": 0, "data": {"message_id": f"om_reply_{len(calls)}"}}
+
+    return SendDriver(create_message=create_message, reply_message=reply_message), calls
+
+
+# ---------------------------------------------------------------------------
+# Long-markdown chunking contract.
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_long_markdown_send_result_exposes_chunk_ids():
+    """Sending a very long markdown body should:
+
+    1. Split into multiple chunks (multiple ``create_message`` driver calls).
+    2. Expose the per-chunk message_ids via ``SendResult.chunk_ids``.
+    """
+    d, calls = _driver()
+    s = OutboundSender(d, OutboundConfig(text_chunk_limit=1000))
+    very_long = "paragraph\n" * 2000  # ~20 KB markdown
+
+    result: SendResult = await s.send(
+        OutboundPost(markdown=very_long), receive_id="oc_1"
+    )
+
+    assert result.success is True
+    create_calls = [c for c in calls if c["op"] == "create"]
+    # Long markdown is split.
+    assert len(create_calls) >= 2, (
+        f"expected long markdown to split into multiple chunks, got "
+        f"{len(create_calls)} create_message call(s)"
+    )
+    # SendResult exposes chunk_ids.
+    chunk_ids = getattr(result, "chunk_ids", None)
+    assert chunk_ids is not None, "SendResult has no chunk_ids attribute"
+    assert isinstance(chunk_ids, list) and len(chunk_ids) >= 2
diff --git a/lark_channel/channel/tests/test_markdown.py b/lark_channel/channel/tests/test_markdown.py
new file mode 100644
index 0000000..b06fa73
--- /dev/null
+++ b/lark_channel/channel/tests/test_markdown.py
@@ -0,0 +1,93 @@
+"""Tests for the Markdown → post AST converter."""
+
+from lark_channel.channel.outbound.markdown import markdown_to_post_ast
+from lark_channel.channel.types import Identity
+
+
+def _zh(ast):
+    return ast["zh_cn"]
+
+
+def test_plain_paragraph():
+    ast = markdown_to_post_ast("hello world")
+    assert _zh(ast)["title"] == ""
+    paras = _zh(ast)["content"]
+    assert paras == [[{"tag": "text", "text": "hello world"}]]
+
+
+def test_heading_becomes_bold_text():
+    ast = markdown_to_post_ast("# Title\n\nbody")
+    paras = _zh(ast)["content"]
+    assert paras[0][0]["style"] == ["bold"] and paras[0][0]["text"] == "Title"
+    assert paras[1] == [{"tag": "text", "text": "body"}]
+
+
+def test_bold_italic_code_inline():
+    ast = markdown_to_post_ast("**bold** and *it* and `code`")
+    paras = _zh(ast)["content"]
+    runs = paras[0]
+    styles = [(r.get("text"), r.get("style", [])) for r in runs if r["tag"] == "text"]
+    assert ("bold", ["bold"]) in styles
+    assert ("it", ["italic"]) in styles
+    assert ("code", ["code"]) in styles
+
+
+def test_link_emits_a_tag():
+    ast = markdown_to_post_ast("see [docs](https://x.example)")
+    runs = _zh(ast)["content"][0]
+    a_tag = next(r for r in runs if r["tag"] == "a")
+    assert a_tag["text"] == "docs"
+    assert a_tag["href"] == "https://x.example"
+
+
+def test_code_block_fenced():
+    ast = markdown_to_post_ast("```python\nprint(1)\n```")
+    paras = _zh(ast)["content"]
+    cb = paras[0][0]
+    assert cb["tag"] == "code_block"
+    assert cb["language"] == "PYTHON"
+    assert cb["text"] == "print(1)"
+
+
+def test_bullet_list_each_paragraph():
+    ast = markdown_to_post_ast("- one\n- two\n- three")
+    paras = _zh(ast)["content"]
+    assert len(paras) == 3
+    assert paras[0][0]["text"].startswith("• one")
+
+
+def test_hr():
+    ast = markdown_to_post_ast("top\n\n---\n\nbot")
+    paras = _zh(ast)["content"]
+    assert any(p == [{"tag": "hr"}] for p in paras)
+
+
+def test_blockquote_marker():
+    ast = markdown_to_post_ast("> quoted line")
+    first = _zh(ast)["content"][0]
+    assert first[0] == {"tag": "text", "text": "│ "}
+
+
+def test_mentions_injected():
+    ast = markdown_to_post_ast(
+        "hi",
+        mentions=[Identity(open_id="ou_1", display_name="Alice")],
+    )
+    first = _zh(ast)["content"][0]
+    # First run is the <at> tag
+    assert first[0]["tag"] == "at"
+    assert first[0]["user_id"] == "ou_1"
+    assert first[0]["user_name"] == "Alice"
+
+
+def test_table_mode_bullets():
+    md = "| name | age |\n|---|---|\n| Alice | 30 |\n| Bob | 25 |"
+    ast = markdown_to_post_ast(md, table_mode="bullets")
+    paras = _zh(ast)["content"]
+    assert paras[0][0]["text"].startswith("• name: Alice")
+    assert paras[1][0]["text"].startswith("• name: Bob")
+
+
+def test_empty_input_yields_empty_paragraph():
+    ast = markdown_to_post_ast("")
+    assert _zh(ast)["content"] == [[]] or _zh(ast)["content"] == [[{"tag": "text", "text": ""}]]
diff --git a/lark_channel/channel/tests/test_markdown_native_mode.py b/lark_channel/channel/tests/test_markdown_native_mode.py
new file mode 100644
index 0000000..ea016dd
--- /dev/null
+++ b/lark_channel/channel/tests/test_markdown_native_mode.py
@@ -0,0 +1,321 @@
+"""tag_md_mode behavior tests."""
+import json
+from dataclasses import fields
+from pathlib import Path
+
+import pytest
+
+from lark_channel.channel.config import MarkdownConverter, OutboundConfig
+from lark_channel.channel.outbound.markdown.to_post import (
+    _split_at_code_fences,
+    markdown_to_post_ast,
+)
+
+
+# Fixture set covering structured and native markdown conversion.
+FIXTURES = {
+    "01_plain": "这是普通文本，没有任何 markdown。",
+    "02_bold": "下面是 **粗体** 文字。",
+    "03_italic": "下面是 *斜体* 文字。",
+    "04_bold_italic": "组合 ***粗+斜*** 看一下。",
+    "05_h1": "# H1 标题（应该字号最大）",
+    "06_h2": "## H2 标题（中号）",
+    "07_h3": "### H3 标题（小号）",
+    "08_quote": "> 这是引用块第一行\n> 引用块第二行",
+    "09_nested_quote": "> 外层引用\n>> 嵌套引用",
+    "10_ul": "- 苹果\n- 香蕉\n- 樱桃",
+    "11_ol": "1. 第一\n2. 第二\n3. 第三",
+    "12_nested_ul": "- 顶层\n  - 子项 1\n  - 子项 2",
+    "13_inline_code": "命令是 `git status` 用来查看状态。",
+    "14_link": "查看 [文档](https://example.com) 了解更多。",
+    "15_code_fence": "```python\nprint('hi')\n```",
+    "16_composite": (
+        "# 标题\n\n"
+        "**重点**：下面是清单。\n\n"
+        "- a\n- b\n\n"
+        "> 引用\n\n"
+        "```python\nprint('done')\n```"
+    ),
+}
+
+
+def test_markdown_converter_has_tag_md_mode_field_with_structured_default():
+    conv = MarkdownConverter()
+    assert conv.tag_md_mode == "structured"
+
+
+def test_markdown_converter_accepts_native_tag_md_mode():
+    conv = MarkdownConverter(tag_md_mode="native")
+    assert conv.tag_md_mode == "native"
+
+
+def test_markdown_converter_field_order_appends_new_field_at_end():
+    # New fields must be appended so positional kwargs in existing call sites
+    # keep working.
+    names = [f.name for f in fields(MarkdownConverter)]
+    assert names[:2] == ["enabled", "table_mode"]
+    assert names[-1] == "tag_md_mode"
+
+
+class TestSplitAtCodeFences:
+    def test_empty_string_returns_empty_list(self):
+        assert _split_at_code_fences("") == []
+
+    def test_plain_text_is_single_segment(self):
+        assert _split_at_code_fences("hello world") == ["hello world"]
+
+    def test_text_with_one_fence_splits_into_three_segments(self):
+        text = "before\n```python\nprint('hi')\n```\nafter"
+        out = _split_at_code_fences(text)
+        # prose before, the fenced block (open+body+close), prose after
+        assert len(out) == 3
+        assert out[0] == "before"
+        assert out[1] == "```python\nprint('hi')\n```"
+        assert out[2] == "after"
+
+    def test_text_starting_with_fence_no_leading_prose_segment(self):
+        text = "```\ncode\n```\ntrailing"
+        out = _split_at_code_fences(text)
+        assert out == ["```\ncode\n```", "trailing"]
+
+    def test_text_ending_with_fence_no_trailing_prose_segment(self):
+        text = "leading\n```\ncode\n```"
+        out = _split_at_code_fences(text)
+        assert out == ["leading", "```\ncode\n```"]
+
+    def test_only_fence_block(self):
+        text = "```python\nprint('x')\n```"
+        assert _split_at_code_fences(text) == ["```python\nprint('x')\n```"]
+
+    def test_unclosed_fence_treated_as_text(self):
+        # Defensive: if no closing fence, the rest of the text is one segment
+        # (don't drop content).
+        text = "before\n```python\nstill open"
+        out = _split_at_code_fences(text)
+        assert "".join(out).count("```") == 1
+        assert "still open" in out[-1]
+
+    def test_two_fences_separated_by_prose(self):
+        text = "a\n```\nx\n```\nb\n```\ny\n```\nc"
+        out = _split_at_code_fences(text)
+        assert out == [
+            "a",
+            "```\nx\n```",
+            "b",
+            "```\ny\n```",
+            "c",
+        ]
+
+
+class TestNativeMode:
+    def test_plain_text_native_returns_single_md_node(self):
+        out = markdown_to_post_ast("hello world", tag_md_mode="native")
+        assert out == {
+            "zh_cn": {
+                "title": "",
+                "content": [[{"tag": "md", "text": "hello world"}]],
+            }
+        }
+
+    def test_header_native_wraps_raw(self):
+        out = markdown_to_post_ast("# Hello", tag_md_mode="native")
+        assert out["zh_cn"]["content"] == [[{"tag": "md", "text": "# Hello"}]]
+
+    def test_blockquote_native_wraps_raw(self):
+        out = markdown_to_post_ast("> quote", tag_md_mode="native")
+        assert out["zh_cn"]["content"] == [[{"tag": "md", "text": "> quote"}]]
+
+    def test_code_fence_native_produces_at_least_two_rows(self):
+        text = "# H1\n\n```python\nprint('hi')\n```"
+        out = markdown_to_post_ast(text, tag_md_mode="native")
+        rows = out["zh_cn"]["content"]
+        assert len(rows) >= 2
+        # Every node in every row must be tag:md
+        for row in rows:
+            for node in row:
+                assert node["tag"] == "md", f"got non-md node: {node}"
+        # The fence segment must be one row, intact
+        fence_rows = [r for r in rows if "```" in r[0]["text"]]
+        assert len(fence_rows) == 1
+        assert fence_rows[0][0]["text"] == "```python\nprint('hi')\n```"
+
+    def test_native_mode_no_structured_nodes_for_all_fixtures(self):
+        for label, text in FIXTURES.items():
+            out = markdown_to_post_ast(text, tag_md_mode="native")
+            for row in out["zh_cn"]["content"]:
+                for node in row:
+                    assert node["tag"] == "md", (
+                        f"fixture {label!r} produced non-md node: {node}"
+                    )
+
+    def test_native_mode_title_propagated(self):
+        out = markdown_to_post_ast("body", title="My Title", tag_md_mode="native")
+        assert out["zh_cn"]["title"] == "My Title"
+
+    def test_native_mode_locale_propagated(self):
+        out = markdown_to_post_ast("body", locale="en_us", tag_md_mode="native")
+        assert "en_us" in out
+
+    def test_empty_input_native_returns_valid_structure(self):
+        out = markdown_to_post_ast("", tag_md_mode="native")
+        rows = out["zh_cn"]["content"]
+        assert isinstance(rows, list)
+
+
+class TestStructuredSnapshot:
+    """Structured-mode output must stay byte-identical to the snapshot."""
+
+    @staticmethod
+    def _load_snapshot():
+        path = Path(__file__).parent / "snapshots" / "markdown_structured.json"
+        return json.loads(path.read_text(encoding="utf-8"))
+
+    def test_structured_default_kwarg_equals_snapshot(self):
+        snapshot = self._load_snapshot()
+        for label, text in FIXTURES.items():
+            actual = markdown_to_post_ast(text)
+            assert actual == snapshot[label], (
+                f"structured-mode regression for {label!r}\n"
+                f"expected: {json.dumps(snapshot[label], ensure_ascii=False)}\n"
+                f"actual:   {json.dumps(actual, ensure_ascii=False)}"
+            )
+
+    def test_structured_explicit_kwarg_equals_default(self):
+        for label, text in FIXTURES.items():
+            assert markdown_to_post_ast(text) == markdown_to_post_ast(
+                text, tag_md_mode="structured"
+            ), f"explicit and default disagree for {label!r}"
+
+
+class TestSenderBuildPost:
+    def test_build_post_default_uses_structured(self):
+        from lark_channel.channel.outbound.sender import _build_post
+        from lark_channel.channel.types import OutboundPost
+
+        msg = OutboundPost(markdown="# Hello")
+        body = _build_post(msg)
+        content = json.loads(body["content"])
+        node = content["zh_cn"]["content"][0][0]
+        assert node["tag"] == "text"
+        assert "bold" in node.get("style", [])
+
+    def test_build_post_native_returns_tag_md(self):
+        from lark_channel.channel.outbound.sender import _build_post
+        from lark_channel.channel.types import OutboundPost
+
+        msg = OutboundPost(markdown="# Hello")
+        body = _build_post(msg, tag_md_mode="native")
+        content = json.loads(body["content"])
+        node = content["zh_cn"]["content"][0][0]
+        assert node == {"tag": "md", "text": "# Hello"}
+
+    def test_build_post_opaque_pass_through_ignores_tag_md_mode(self):
+        from lark_channel.channel.outbound.sender import _build_post
+        from lark_channel.channel.types import OutboundPost
+
+        ast = {"zh_cn": {"title": "", "content": [[{"tag": "text", "text": "x"}]]}}
+        msg = OutboundPost(post=ast)
+        body_default = _build_post(msg)
+        body_native = _build_post(msg, tag_md_mode="native")
+        assert body_default == body_native
+        assert json.loads(body_default["content"]) == ast
+
+
+class TestEnabledPriority:
+    """enabled=False overrides tag_md_mode=native."""
+
+    def test_disabled_converter_branch_picks_structured(self):
+        # Replicate the sender's branch logic exactly:
+        conv = MarkdownConverter(enabled=False, tag_md_mode="native")
+        if getattr(conv, "enabled", True):
+            tag_md_mode = getattr(conv, "tag_md_mode", "structured")
+        else:
+            tag_md_mode = "structured"
+        assert tag_md_mode == "structured"
+
+    def test_disabled_converter_via_sender_uses_structured(self):
+        # Even when MarkdownConverter is configured with native, disabling
+        # the converter forces structured (plain-text fallback) at _materialize.
+        from lark_channel.channel.config import OutboundConfig
+        from lark_channel.channel.outbound.sender import OutboundSender
+        from lark_channel.channel.tests.test_sender import make_driver
+        from lark_channel.channel.types import OutboundPost
+
+        async def _run():
+            d, calls = make_driver()
+            cfg = OutboundConfig(
+                markdown_converter=MarkdownConverter(
+                    enabled=False, tag_md_mode="native",
+                ),
+            )
+            s = OutboundSender(d, cfg)
+            await s.send(OutboundPost(markdown="# Hello"), receive_id="oc_x")
+            content = json.loads(calls[0]["content"])
+            node = content["zh_cn"]["content"][0][0]
+            # enabled=False -> structured path, header collapses to bold tag:text
+            assert node["tag"] == "text"
+            assert "bold" in node.get("style", [])
+
+        import asyncio
+        asyncio.run(_run())
+
+
+class TestSenderEndToEndNativeMode:
+    """Sender plumbing produces tag:md when configured with native mode."""
+
+    @pytest.mark.asyncio
+    async def test_outbound_post_native_produces_tag_md_only_payload(self):
+        from lark_channel.channel.outbound.sender import OutboundSender
+        from lark_channel.channel.tests.test_sender import make_driver
+        from lark_channel.channel.types import OutboundPost
+
+        d, calls = make_driver()
+        cfg = OutboundConfig(
+            markdown_converter=MarkdownConverter(tag_md_mode="native"),
+        )
+        s = OutboundSender(d, cfg)
+        await s.send(
+            OutboundPost(markdown="# Hello\n\n- a\n- b"),
+            receive_id="oc_x",
+        )
+        assert calls[0]["msg_type"] == "post"
+        content = json.loads(calls[0]["content"])
+        for row in content["zh_cn"]["content"]:
+            for node in row:
+                assert node["tag"] == "md", f"non-md node leaked: {node}"
+
+    @pytest.mark.asyncio
+    async def test_outbound_post_default_still_produces_structured_payload(self):
+        from lark_channel.channel.outbound.sender import OutboundSender
+        from lark_channel.channel.tests.test_sender import make_driver
+        from lark_channel.channel.types import OutboundPost
+
+        d, calls = make_driver()
+        s = OutboundSender(d)  # default OutboundConfig: structured
+        await s.send(OutboundPost(markdown="# Hello"), receive_id="oc_x")
+        content = json.loads(calls[0]["content"])
+        node = content["zh_cn"]["content"][0][0]
+        assert node["tag"] == "text"
+        assert "bold" in node.get("style", [])
+
+    @pytest.mark.asyncio
+    async def test_outbound_post_native_with_code_fence_produces_multi_row(self):
+        from lark_channel.channel.config import OutboundConfig
+        from lark_channel.channel.outbound.sender import OutboundSender
+        from lark_channel.channel.tests.test_sender import make_driver
+        from lark_channel.channel.types import OutboundPost
+
+        d, calls = make_driver()
+        cfg = OutboundConfig(
+            markdown_converter=MarkdownConverter(tag_md_mode="native"),
+        )
+        s = OutboundSender(d, cfg)
+        await s.send(
+            OutboundPost(markdown="# H1\n\n```python\nprint('hi')\n```"),
+            receive_id="oc_x",
+        )
+        content = json.loads(calls[0]["content"])
+        rows = content["zh_cn"]["content"]
+        assert len(rows) >= 2
+        fence_rows = [r for r in rows if "```" in r[0]["text"]]
+        assert len(fence_rows) == 1
diff --git a/lark_channel/channel/tests/test_media_batch.py b/lark_channel/channel/tests/test_media_batch.py
new file mode 100644
index 0000000..cf80969
--- /dev/null
+++ b/lark_channel/channel/tests/test_media_batch.py
@@ -0,0 +1,157 @@
+"""Media batching integration tests.
+
+Covered behavior:
+1. 5 consecutive images -> 1 dispatch with batched_sources length == 5
+2. img -> img -> text -> img -> 3 dispatches in order: media_batch(2), text, media(1)
+3. img -> file -> 2 dispatches (incompatible kinds)
+4. enabled=False -> no batching, 5 dispatches
+"""
+
+import asyncio
+import time
+
+import pytest
+
+from lark_channel.channel import (
+    ChatQueueConfig,
+    DedupConfig,
+    MediaBatchConfig,
+    TextBatchConfig,
+)
+from lark_channel.channel.safety import SafetyPipeline
+from lark_channel.channel.types import (
+    Conversation,
+    FileContent,
+    Identity,
+    ImageContent,
+    InboundMessage,
+    TextContent,
+)
+
+
+def _img(mid: str, *, chat_id: str = "c1") -> InboundMessage:
+    return InboundMessage(
+        id=mid,
+        create_time=int(time.time() * 1000),
+        conversation=Conversation(chat_id=chat_id, chat_type="p2p"),
+        sender=Identity(open_id="ou_user"),
+        content=ImageContent(image_key=f"img_{mid}"),
+        raw_content_type="image",
+    )
+
+
+def _file(mid: str, *, chat_id: str = "c1") -> InboundMessage:
+    return InboundMessage(
+        id=mid,
+        create_time=int(time.time() * 1000),
+        conversation=Conversation(chat_id=chat_id, chat_type="p2p"),
+        sender=Identity(open_id="ou_user"),
+        content=FileContent(file_key=f"f_{mid}"),
+        raw_content_type="file",
+    )
+
+
+def _text(mid: str, *, chat_id: str = "c1") -> InboundMessage:
+    return InboundMessage(
+        id=mid,
+        create_time=int(time.time() * 1000),
+        conversation=Conversation(chat_id=chat_id, chat_type="p2p"),
+        sender=Identity(open_id="ou_user"),
+        content=TextContent(text=f"t-{mid}"),
+        raw_content_type="text",
+    )
+
+
+@pytest.mark.asyncio
+async def test_five_consecutive_images_merge_to_one_dispatch():
+    delivered = []
+
+    async def on_message(m):
+        delivered.append(m)
+
+    loop = asyncio.get_running_loop()
+    pipe = SafetyPipeline(
+        loop=loop,
+        on_message=on_message,
+        media_batch_config=MediaBatchConfig(enabled=True, delay_ms=50, max_items=9),
+        # disable text batch + chat_queue + dedup so we isolate media batch behavior
+        batch_config=TextBatchConfig(delay_ms=0, max_messages=1),
+        queue_config=ChatQueueConfig(enabled=False),
+        dedup_config=DedupConfig(enabled=False),
+    )
+    for i in range(5):
+        await pipe.push_message(_img(f"m{i}"))
+    await asyncio.sleep(0.2)  # > delay_ms
+    assert len(delivered) == 1, f"expected 1 merged dispatch, got {len(delivered)}"
+    assert delivered[0].batched_sources is not None
+    assert len(delivered[0].batched_sources) == 5
+
+
+@pytest.mark.asyncio
+async def test_img_img_text_img_three_dispatches():
+    delivered = []
+
+    async def on_message(m):
+        delivered.append(m.raw_content_type)
+
+    loop = asyncio.get_running_loop()
+    pipe = SafetyPipeline(
+        loop=loop,
+        on_message=on_message,
+        media_batch_config=MediaBatchConfig(enabled=True, delay_ms=50, max_items=9),
+        batch_config=TextBatchConfig(delay_ms=0, max_messages=1),
+        queue_config=ChatQueueConfig(enabled=False),
+        dedup_config=DedupConfig(enabled=False),
+    )
+    await pipe.push_message(_img("m1"))
+    await pipe.push_message(_img("m2"))
+    await pipe.push_message(_text("m3"))           # text forces media flush
+    await pipe.push_message(_img("m4"))
+    await asyncio.sleep(0.2)
+
+    assert delivered == ["image", "text", "image"], delivered
+
+
+@pytest.mark.asyncio
+async def test_image_file_dispatched_separately():
+    delivered = []
+
+    async def on_message(m):
+        delivered.append(m.raw_content_type)
+
+    loop = asyncio.get_running_loop()
+    pipe = SafetyPipeline(
+        loop=loop,
+        on_message=on_message,
+        media_batch_config=MediaBatchConfig(enabled=True, delay_ms=50),
+        batch_config=TextBatchConfig(delay_ms=0, max_messages=1),
+        queue_config=ChatQueueConfig(enabled=False),
+        dedup_config=DedupConfig(enabled=False),
+    )
+    await pipe.push_message(_img("m1"))
+    await pipe.push_message(_file("m2"))   # file != image, force flush
+    await asyncio.sleep(0.2)
+
+    assert delivered == ["image", "file"], delivered
+
+
+@pytest.mark.asyncio
+async def test_disabled_no_batching():
+    delivered = []
+
+    async def on_message(m):
+        delivered.append(m.id)
+
+    loop = asyncio.get_running_loop()
+    pipe = SafetyPipeline(
+        loop=loop,
+        on_message=on_message,
+        media_batch_config=MediaBatchConfig(enabled=False),
+        batch_config=TextBatchConfig(delay_ms=0, max_messages=1),
+        queue_config=ChatQueueConfig(enabled=False),
+        dedup_config=DedupConfig(enabled=False),
+    )
+    for i in range(5):
+        await pipe.push_message(_img(f"m{i}"))
+    await asyncio.sleep(0.2)
+    assert delivered == ["m0", "m1", "m2", "m3", "m4"]
diff --git a/lark_channel/channel/tests/test_media_caption.py b/lark_channel/channel/tests/test_media_caption.py
new file mode 100644
index 0000000..a070c75
--- /dev/null
+++ b/lark_channel/channel/tests/test_media_caption.py
@@ -0,0 +1,193 @@
+"""Image/file caption tests."""
+
+import json
+from typing import Any, Dict, List
+
+import pytest
+
+from lark_channel.channel._coerce import coerce_outbound
+from lark_channel.channel.config import MarkdownConverter, OutboundConfig
+from lark_channel.channel.outbound.sender import OutboundSender, SendDriver
+from lark_channel.channel.types import (
+    MediaSource,
+    OutboundAudio,
+    OutboundFile,
+    OutboundImage,
+    OutboundVideo,
+)
+
+
+def test_coerce_image_caption():
+    out = coerce_outbound({"image": {"source": "img_key"}, "caption": "hello"})
+    assert isinstance(out, OutboundImage)
+    assert out.caption == "hello"
+
+
+def test_coerce_file_caption():
+    out = coerce_outbound({"file": {"source": b"abc", "fileName": "a.txt"}, "caption": "file cap"})
+    assert isinstance(out, OutboundFile)
+    assert out.caption == "file cap"
+    assert out.file_name == "a.txt"
+
+
+def test_coerce_empty_caption_as_none():
+    out = coerce_outbound({"image": {"source": "img_key"}, "caption": ""})
+    assert isinstance(out, OutboundImage)
+    assert out.caption is None
+
+
+def test_coerce_non_string_caption_rejected():
+    with pytest.raises(TypeError, match="caption must be a string"):
+        coerce_outbound({"image": {"source": "img_key"}, "caption": 123})
+
+
+def test_coerce_audio_video_caption():
+    audio = coerce_outbound({"audio": {"source": b"audio"}, "caption": "audio cap"})
+    video = coerce_outbound({"video": {"source": b"video"}, "caption": "video cap"})
+    assert isinstance(audio, OutboundAudio)
+    assert isinstance(video, OutboundVideo)
+    assert audio.caption == "audio cap"
+    assert video.caption == "video cap"
+
+
+def make_caption_driver(image_key="img_x", file_key="file_x"):
+    calls: List[Dict[str, Any]] = []
+
+    async def create_message(**kwargs):
+        calls.append({"op": "create", **kwargs})
+        return {"code": 0, "msg": "ok", "data": {"message_id": "om_new"}}
+
+    async def upload_image(**kwargs):
+        calls.append({"op": "upload_image", **{k: v for k, v in kwargs.items() if k != "data"}})
+        return {"code": 0, "data": {"image_key": image_key}}
+
+    async def upload_file(**kwargs):
+        calls.append({"op": "upload_file", **{k: v for k, v in kwargs.items() if k != "data"}})
+        return {"code": 0, "data": {"file_key": file_key}}
+
+    return SendDriver(
+        create_message=create_message,
+        reply_message=create_message,
+        upload_image=upload_image,
+        upload_file=upload_file,
+    ), calls
+
+
+@pytest.mark.asyncio
+async def test_image_without_caption_wire_unchanged():
+    d, calls = make_caption_driver(image_key="img_no_cap")
+    s = OutboundSender(d)
+    await s.send(
+        OutboundImage(source=MediaSource(kind="buffer", buffer=b"png")),
+        receive_id="oc_1",
+    )
+    create = [c for c in calls if c["op"] == "create"][0]
+    assert create["msg_type"] == "image"
+    assert json.loads(create["content"]) == {"image_key": "img_no_cap"}
+
+
+@pytest.mark.asyncio
+async def test_file_without_caption_wire_unchanged():
+    d, calls = make_caption_driver(file_key="file_no_cap")
+    s = OutboundSender(d)
+    await s.send(
+        OutboundFile(source=MediaSource(kind="buffer", buffer=b"abc"), file_name="a.txt"),
+        receive_id="oc_1",
+    )
+    create = [c for c in calls if c["op"] == "create"][0]
+    assert create["msg_type"] == "file"
+    assert json.loads(create["content"]) == {"file_key": "file_no_cap"}
+
+
+@pytest.mark.asyncio
+async def test_image_caption_native_post_body():
+    d, calls = make_caption_driver(image_key="img_cap")
+    cfg = OutboundConfig(markdown_converter=MarkdownConverter(tag_md_mode="native"))
+    s = OutboundSender(d, cfg)
+    await s.send(
+        OutboundImage(source=MediaSource(kind="buffer", buffer=b"png"), caption="**caption**"),
+        receive_id="oc_1",
+    )
+    create = [c for c in calls if c["op"] == "create"][0]
+    assert create["msg_type"] == "post"
+    post = json.loads(create["content"])
+    assert post["zh_cn"]["content"] == [
+        [{"tag": "md", "text": "**caption**"}],
+        [{"tag": "img", "image_key": "img_cap"}],
+    ]
+
+
+@pytest.mark.asyncio
+async def test_file_caption_is_rejected_without_uploading_or_sending():
+    d, calls = make_caption_driver(file_key="file_cap")
+    cfg = OutboundConfig(markdown_converter=MarkdownConverter(tag_md_mode="native"))
+    s = OutboundSender(d, cfg)
+    result = await s.send(
+        OutboundFile(
+            source=MediaSource(kind="buffer", buffer=b"abc"),
+            file_name="a.txt",
+            caption="file caption",
+        ),
+        receive_id="oc_1",
+    )
+    assert result.success is False
+    assert result.error is not None
+    assert result.error.code.value == "format_error"
+    assert "file caption" in (result.error.hint or "")
+    assert calls == []
+
+
+@pytest.mark.asyncio
+async def test_audio_caption_is_rejected_without_uploading_or_sending():
+    d, calls = make_caption_driver(file_key="audio_cap")
+    cfg = OutboundConfig(markdown_converter=MarkdownConverter(tag_md_mode="native"))
+    s = OutboundSender(d, cfg)
+    result = await s.send(
+        OutboundAudio(
+            source=MediaSource(kind="buffer", buffer=b"abc"),
+            caption="audio caption",
+        ),
+        receive_id="oc_1",
+    )
+    assert result.success is False
+    assert result.error is not None
+    assert result.error.code.value == "format_error"
+    assert "audio caption" in (result.error.hint or "")
+    assert calls == []
+
+
+@pytest.mark.asyncio
+async def test_video_caption_native_post_body_uses_media_tag():
+    d, calls = make_caption_driver(file_key="video_cap")
+    cfg = OutboundConfig(markdown_converter=MarkdownConverter(tag_md_mode="native"))
+    s = OutboundSender(d, cfg)
+    await s.send(
+        OutboundVideo(
+            source=MediaSource(kind="buffer", buffer=b"abc"),
+            caption="video caption",
+        ),
+        receive_id="oc_1",
+    )
+    create = [c for c in calls if c["op"] == "create"][0]
+    assert create["msg_type"] == "post"
+    post = json.loads(create["content"])
+    assert post["zh_cn"]["content"] == [
+        [{"tag": "md", "text": "video caption"}],
+        [{"tag": "media", "file_key": "video_cap"}],
+    ]
+
+
+@pytest.mark.asyncio
+async def test_image_caption_structured_adds_media_as_final_row():
+    d, calls = make_caption_driver(image_key="img_structured")
+    s = OutboundSender(d)
+    await s.send(
+        OutboundImage(source=MediaSource(kind="buffer", buffer=b"png"), caption="**bold**"),
+        receive_id="oc_1",
+    )
+    create = [c for c in calls if c["op"] == "create"][0]
+    post = json.loads(create["content"])
+    rows = post["zh_cn"]["content"]
+    assert rows[-1] == [{"tag": "img", "image_key": "img_structured"}]
+    assert rows[0][0]["tag"] == "text"
+    assert rows[0][0]["text"] == "bold"
diff --git a/lark_channel/channel/tests/test_media_upload_download_regressions.py b/lark_channel/channel/tests/test_media_upload_download_regressions.py
new file mode 100644
index 0000000..a79392f
--- /dev/null
+++ b/lark_channel/channel/tests/test_media_upload_download_regressions.py
@@ -0,0 +1,156 @@
+"""Regression tests for media serialization, upload response shape, and SSRF."""
+
+from types import SimpleNamespace
+from typing import Optional
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from lark_channel.channel.driver import LarkClientDriver, _resp_to_dict
+from lark_channel.channel.errors import FeishuChannelError, FeishuChannelErrorCode
+from lark_channel.channel.outbound.media.uploader import (
+    gather_buffer,
+    resolve_media_key,
+)
+from lark_channel.channel.types import MediaSource
+from lark_channel.core.json import JSON
+
+
+# --------------------------------------------------------------------------- #
+# JSON.marshal must not blow up on non-UTF-8 bytes (JPEG magic bytes).
+# --------------------------------------------------------------------------- #
+
+
+# JPEG SOI + APP0 header: 0xff 0xd8 0xff 0xe0 — classic "not valid UTF-8" blob.
+_JPEG_BYTES = b"\xff\xd8\xff\xe0\x00\x10JFIF\x00"
+
+
+def test_json_marshal_handles_raw_image_bytes():
+    """Binary response bytes can be serialized through ``JSON.marshal``."""
+    payload = {"file_key": "file_abc", "content": _JPEG_BYTES}
+    out = JSON.marshal(payload)
+    assert isinstance(out, str)
+    import json as _json
+
+    back = _json.loads(out)
+    assert back["file_key"] == "file_abc"
+    # We don't care what encoding the SDK chooses — only that it doesn't
+    # crash and preserves the blob as *some* string.
+    assert isinstance(back["content"], str)
+    assert len(back["content"]) > 0
+
+
+def test_json_marshal_nested_bytes_in_response_like_object():
+    """Response-like objects containing bytes serialize without raising."""
+
+    class _FakeResp:
+        def __init__(self) -> None:
+            self.code = 0
+            self.msg = ""
+            self.file_bytes = _JPEG_BYTES
+            self.file_name = "photo.jpg"
+
+    out = JSON.marshal(_FakeResp())
+    assert isinstance(out, str)
+    import json as _json
+
+    back = _json.loads(out)
+    assert back["file_name"] == "photo.jpg"
+    assert isinstance(back["file_bytes"], str)
+
+
+# --------------------------------------------------------------------------- #
+# driver.upload_file contract — returns {"code", "msg", "data":
+# {"file_key": ...}}
+# --------------------------------------------------------------------------- #
+
+
+def _stub_client_for_upload(file_key: Optional[str]) -> MagicMock:
+    c = MagicMock()
+    data = MagicMock()
+    # attribute-access returns the key; _resp_to_dict round-trips via
+    # JSON.marshal → vars(), so we need a real object with __dict__.
+    data.__dict__ = {"file_key": file_key} if file_key is not None else {}
+    resp = MagicMock()
+    resp.code = 0
+    resp.msg = ""
+    resp.data = SimpleNamespace(file_key=file_key) if file_key is not None else None
+    c.im.v1.file.acreate = AsyncMock(return_value=resp)
+    c.im.v1.image.acreate = AsyncMock(return_value=resp)
+    return c
+
+
+@pytest.mark.asyncio
+async def test_upload_file_signature_returns_file_key_shape():
+    """``driver.upload_file`` returns a dict with ``data.file_key``.
+    """
+    c = _stub_client_for_upload(file_key="file_xyz")
+    d = LarkClientDriver(c)
+    raw = await d.upload_file(
+        data=b"%PDF-1.4 test",
+        file_name="sample.pdf",
+        file_type="pdf",
+    )
+    assert isinstance(raw, dict)
+    assert raw.get("code") == 0
+    # The field downstream callers rely on.
+    data = raw.get("data") or {}
+    assert data.get("file_key") == "file_xyz", (
+        "driver.upload_file must surface data.file_key in the dict "
+        "returned to callers."
+    )
+
+
+@pytest.mark.asyncio
+async def test_upload_file_preserves_file_key_through_resp_to_dict():
+    """Direct ``_resp_to_dict`` test — guards against a regression where the
+    marshaller drops ``file_key`` (e.g. filter_null or a wrong type map)."""
+
+    # Build a response that looks like the real CreateFileResponse shape.
+    class _Body:
+        def __init__(self) -> None:
+            self.file_key = "file_abcdef"
+
+    resp = SimpleNamespace(code=0, msg="", data=_Body())
+    out = _resp_to_dict(resp)
+    assert out["code"] == 0
+    assert (out.get("data") or {}).get("file_key") == "file_abcdef"
+
+
+# --------------------------------------------------------------------------- #
+# URL-sourced media without allowlist must surface SSRF_BLOCKED, not
+# silently return None.
+# --------------------------------------------------------------------------- #
+
+
+@pytest.mark.asyncio
+async def test_gather_buffer_url_without_allowlist_raises_ssrf_blocked():
+    """URL downloads without an allowlist raise a typed SSRF_BLOCKED error.
+
+    Returning ``None`` is indistinguishable from a transient network failure
+    and can't be matched on.
+    """
+    src = MediaSource(kind="url", url="http://169.254.169.254/latest/meta-data/")
+    with pytest.raises(FeishuChannelError) as ei:
+        await gather_buffer(src, default_name="x.bin")
+    assert ei.value.code == FeishuChannelErrorCode.SSRF_BLOCKED
+
+
+@pytest.mark.asyncio
+async def test_resolve_media_key_url_without_allowlist_raises():
+    """End-to-end uploader path: sending an OutboundImage whose source is a
+    private-IP URL should surface ``FeishuChannelError(SSRF_BLOCKED)`` to the
+    caller, not quietly downgrade to ``key=None`` (which produces an empty
+    message body)."""
+
+    async def _never_called(**kwargs):  # pragma: no cover - defensive
+        raise AssertionError("uploader must not be invoked for blocked URL")
+
+    driver = SimpleNamespace(
+        upload_image=_never_called,
+        upload_file=_never_called,
+    )
+    src = MediaSource(kind="url", url="http://127.0.0.1:8080/internal.png")
+    with pytest.raises(FeishuChannelError) as ei:
+        await resolve_media_key(driver, src, "image")
+    assert ei.value.code == FeishuChannelErrorCode.SSRF_BLOCKED
diff --git a/lark_channel/channel/tests/test_media_upload_response_contract.py b/lark_channel/channel/tests/test_media_upload_response_contract.py
new file mode 100644
index 0000000..003ae59
--- /dev/null
+++ b/lark_channel/channel/tests/test_media_upload_response_contract.py
@@ -0,0 +1,389 @@
+"""Media upload and standalone resource download response contracts.
+
+These tests cover two contracts:
+
+- Upload helpers pass file payloads as named ``io.IOBase`` streams so the
+  multipart serializer includes the image/file part.
+- Standalone image/file keys download through the standalone resource
+  endpoints when no ``message_id`` is available.
+
+SSRF blocking behavior is covered in
+:mod:`test_media_upload_download_regressions` and
+:mod:`test_seen_cache_and_ssrf_paths`.
+"""
+
+import io
+from unittest.mock import AsyncMock, MagicMock, Mock
+
+import pytest
+
+from lark_channel.api.im.v1.model.create_file_response import CreateFileResponse
+from lark_channel.api.im.v1.model.create_file_response_body import CreateFileResponseBody
+from lark_channel.api.im.v1.model.create_image_response import CreateImageResponse
+from lark_channel.api.im.v1.model.create_image_response_body import CreateImageResponseBody
+from lark_channel.channel import _api_helpers
+from lark_channel.channel.driver import LarkClientDriver, _resp_to_dict
+from lark_channel.channel.outbound.media.uploader import _unwrap
+
+
+# ---------------------------------------------------------------------------
+# Real response objects.
+# ---------------------------------------------------------------------------
+
+
+def test_resp_to_dict_extracts_image_key_from_real_response():
+    body = CreateImageResponseBody.builder().image_key("img_v2_real").build()
+    resp = CreateImageResponse()
+    resp.code = 0
+    resp.msg = "ok"
+    resp.data = body
+
+    out = _resp_to_dict(resp)
+    assert out["code"] == 0
+    assert out["data"]["image_key"] == "img_v2_real"
+
+
+def test_resp_to_dict_extracts_file_key_from_real_response():
+    body = CreateFileResponseBody.builder().file_key("file_v2_real").build()
+    resp = CreateFileResponse()
+    resp.code = 0
+    resp.msg = "ok"
+    resp.data = body
+
+    out = _resp_to_dict(resp)
+    assert out["code"] == 0
+    assert out["data"]["file_key"] == "file_v2_real"
+
+
+def test_unwrap_passes_through_real_response_body():
+    body = CreateImageResponseBody.builder().image_key("img_via_unwrap").build()
+    resp = CreateImageResponse()
+    resp.code = 0
+    resp.data = body
+
+    out = _unwrap(resp)
+    assert out["data"]["image_key"] == "img_via_unwrap"
+
+
+# ---------------------------------------------------------------------------
+# Mock responses also preserve upload keys through fallback extraction.
+# ---------------------------------------------------------------------------
+
+
+def test_resp_to_dict_handles_mock_spec_body_via_dir_fallback():
+    """``JSON.marshal(Mock(spec=Body))`` raises ``TypeError: cannot pickle
+    'mappingproxy'``; the except branch falls back to ``dir()`` sweep and
+    still surfaces the explicitly-set ``image_key``."""
+    mock_body = Mock(spec=CreateImageResponseBody)
+    mock_body.image_key = "img_mock_spec"
+
+    resp = CreateImageResponse()
+    resp.code = 0
+    resp.msg = "ok"
+    resp.data = mock_body
+
+    out = _resp_to_dict(resp)
+    assert out["code"] == 0
+    assert out["data"]["image_key"] == "img_mock_spec"
+
+
+def test_unwrap_extracts_image_key_via_dir_from_mock_spec_body():
+    """``_unwrap`` doesn't try JSON.marshal at all for non-dict data; it
+    uses ``dir()`` directly, which handles mock objects natively."""
+    mock_body = Mock(spec=CreateImageResponseBody)
+    mock_body.image_key = "img_unwrap_mock"
+
+    # ``_unwrap`` accepts either a typed response-like object or a dict.
+    fake_response_like = Mock()
+    fake_response_like.code = 0
+    fake_response_like.msg = "ok"
+    fake_response_like.data = mock_body
+
+    out = _unwrap(fake_response_like)
+    assert out["code"] == 0
+    assert out["data"]["image_key"] == "img_unwrap_mock"
+
+
+def test_unwrap_passthrough_when_driver_already_returned_dict():
+    """After ``driver.upload_image`` runs its own ``_resp_to_dict``, the
+    result is already a plain dict. ``_unwrap`` must pass it through
+    without re-processing (else the wire contract breaks)."""
+    pre_normalised = {
+        "code": 0,
+        "msg": "ok",
+        "data": {"image_key": "img_already_dict"},
+    }
+    out = _unwrap(pre_normalised)
+    assert out is pre_normalised  # identity, not a copy — cheap passthrough
+
+
+# ---------------------------------------------------------------------------
+# End-to-end: full upload pipeline through ``resolve_media_key``
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_resolve_media_key_image_end_to_end():
+    """Exercise the full chain the sender walks: a driver that returns a
+    realistic dict (as the real ``LarkClientDriver.upload_image`` would
+    after running ``_resp_to_dict``), and assert that ``resolve_media_key``
+    returns the image_key string.
+
+    This is the regression guard for "empty body" reports: if ANY step in
+    this chain drops the key, ``resolve_media_key`` returns ``None`` and
+    the sender emits ``SendResult.fail(UNKNOWN, "empty body")``."""
+    from lark_channel.channel.outbound.media.uploader import resolve_media_key
+    from lark_channel.channel.outbound.sender import SendDriver
+    from lark_channel.channel.types import MediaSource
+    from unittest.mock import AsyncMock
+
+    fake_upload_image = AsyncMock(
+        return_value={"code": 0, "msg": "", "data": {"image_key": "img_e2e"}}
+    )
+    driver = SendDriver(
+        create_message=AsyncMock(),
+        reply_message=AsyncMock(),
+        upload_image=fake_upload_image,
+        upload_file=AsyncMock(),
+    )
+    src = MediaSource(kind="buffer", buffer=b"\x89PNG\r\n\x1a\n...")
+    key = await resolve_media_key(driver, src, "image")
+    assert key == "img_e2e"
+    fake_upload_image.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+async def test_resolve_media_key_file_end_to_end():
+    from lark_channel.channel.outbound.media.uploader import resolve_media_key
+    from lark_channel.channel.outbound.sender import SendDriver
+    from lark_channel.channel.types import MediaSource
+    from unittest.mock import AsyncMock
+
+    fake_upload_file = AsyncMock(
+        return_value={"code": 0, "msg": "", "data": {"file_key": "file_e2e"}}
+    )
+    driver = SendDriver(
+        create_message=AsyncMock(),
+        reply_message=AsyncMock(),
+        upload_image=AsyncMock(),
+        upload_file=fake_upload_file,
+    )
+    src = MediaSource(kind="buffer", buffer=b"%PDF-1.7...")
+    key = await resolve_media_key(driver, src, "file", file_name="sample.pdf")
+    assert key == "file_e2e"
+
+
+@pytest.mark.asyncio
+async def test_upload_image_via_real_driver_response_shape():
+    """Full loop: driver.upload_image's actual internal pipeline uses
+    ``_resp_to_dict`` on a real ``CreateImageResponse``. Here we mock only
+    ``self._client.im.v1.image.acreate`` and let the rest run for real, so
+    any regression in ``_resp_to_dict`` would surface here — NOT in a
+    separately-crafted dict fixture.
+    """
+    body = CreateImageResponseBody.builder().image_key("img_driver_e2e").build()
+    resp = CreateImageResponse()
+    resp.code = 0
+    resp.msg = "ok"
+    resp.data = body
+
+    client = MagicMock()
+    client.im.v1.image.acreate = AsyncMock(return_value=resp)
+
+    driver = LarkClientDriver(client)
+    out = await driver.upload_image(data=b"\x89PNG\r\n", file_name="x.png")
+    assert out["code"] == 0
+    assert out["data"]["image_key"] == "img_driver_e2e"
+
+
+# ---------------------------------------------------------------------------
+# Real root cause 1: upload must pass an IO stream, not raw bytes.
+# ---------------------------------------------------------------------------
+
+
+def _captured_image_body(client_mock: MagicMock) -> object:
+    """Pull the `request_body` off the ``CreateImageRequest`` the driver
+    handed to ``image.acreate``. A single ``.call_args`` assertion would
+    be fragile (SDK may wrap in RequestOption), so we match by object
+    type instead."""
+    from lark_channel.api.im.v1.model.create_image_request import CreateImageRequest
+
+    call_args = client_mock.im.v1.image.acreate.call_args
+    req = next(a for a in call_args.args if isinstance(a, CreateImageRequest))
+    return req.request_body
+
+
+def _captured_file_body(client_mock: MagicMock) -> object:
+    from lark_channel.api.im.v1.model.create_file_request import CreateFileRequest
+
+    call_args = client_mock.im.v1.file.acreate.call_args
+    req = next(a for a in call_args.args if isinstance(a, CreateFileRequest))
+    return req.request_body
+
+
+@pytest.mark.asyncio
+async def test_upload_image_passes_iobase_stream_not_bytes():
+    """``Files.extract_files`` only picks up fields
+    that are ``io.IOBase`` instances. If the driver passes raw ``bytes``,
+    the multipart part is silently dropped and the server returns
+    ``234001 Invalid request param``.
+
+    This test mocks the low-level client and asserts the ``image`` field on
+    the outgoing request body is an ``IOBase`` carrying the original bytes
+    and a filename — which is what the Feishu API actually needs to accept
+    the upload."""
+    resp = CreateImageResponse()
+    resp.code = 0
+    resp.msg = "ok"
+    resp.data = CreateImageResponseBody.builder().image_key("img_ok").build()
+
+    client = MagicMock()
+    client.im.v1.image.acreate = AsyncMock(return_value=resp)
+
+    driver = LarkClientDriver(client)
+    payload = b"\x89PNG\r\n\x1a\nbody-bytes"
+    await driver.upload_image(data=payload, file_name="sample.png")
+
+    body = _captured_image_body(client)
+    assert body.image_type == "message"
+    assert isinstance(body.image, io.IOBase), (
+        f"driver must pass io.IOBase (SDK's Files.extract_files filter); "
+        f"got {type(body.image).__name__}"
+    )
+    # filename is required for the multipart Content-Disposition
+    assert getattr(body.image, "name", "") == "sample.png"
+    # and the IO must yield the original payload when read
+    body.image.seek(0)
+    assert body.image.read() == payload
+
+
+@pytest.mark.asyncio
+async def test_upload_file_passes_iobase_stream_not_bytes():
+    """Same IOBase requirement, on the file endpoint. Also pin that the
+    file_name is plumbed through both the dedicated ``file_name`` field AND
+    the IO stream's ``.name`` (the SDK looks at both in different code
+    paths)."""
+    from lark_channel.api.im.v1.model.create_file_response_body import CreateFileResponseBody as _Body
+    resp = CreateFileResponse()
+    resp.code = 0
+    resp.msg = "ok"
+    resp.data = _Body.builder().file_key("file_ok").build()
+
+    client = MagicMock()
+    client.im.v1.file.acreate = AsyncMock(return_value=resp)
+
+    driver = LarkClientDriver(client)
+    payload = b"%PDF-1.7\nbinary-ish\x00\xff"
+    await driver.upload_file(
+        data=payload, file_name="doc.pdf", file_type="pdf"
+    )
+
+    body = _captured_file_body(client)
+    assert body.file_type == "pdf"
+    assert body.file_name == "doc.pdf"
+    assert isinstance(body.file, io.IOBase)
+    assert getattr(body.file, "name", "") == "doc.pdf"
+    body.file.seek(0)
+    assert body.file.read() == payload
+
+
+@pytest.mark.asyncio
+async def test_upload_file_uses_default_name_when_caller_omits_it():
+    """Don't break existing callers that don't pass file_name — the stream
+    still needs *some* ``.name`` so the multipart Content-Disposition is
+    valid."""
+    resp = CreateFileResponse()
+    resp.code = 0
+    resp.data = CreateFileResponseBody.builder().file_key("file_noname").build()
+
+    client = MagicMock()
+    client.im.v1.file.acreate = AsyncMock(return_value=resp)
+
+    driver = LarkClientDriver(client)
+    await driver.upload_file(data=b"bytes")
+
+    body = _captured_file_body(client)
+    assert body.file_name  # some non-empty default
+    assert getattr(body.file, "name", "") == body.file_name
+
+
+# ---------------------------------------------------------------------------
+# Real root cause 2: download_media must route by presence of message_id.
+# ---------------------------------------------------------------------------
+
+
+class _FakeFile:
+    def __init__(self, data: bytes) -> None:
+        self._data = data
+
+    def read(self) -> bytes:
+        return self._data
+
+
+@pytest.mark.asyncio
+async def test_download_image_without_message_id_uses_image_get():
+    """Standalone image key (uploaded via ``image.create`` then downloaded
+    by key only): must hit ``GET /im/v1/images/:image_key``, not the
+    ``/messages/:id/resources/:file_key`` endpoint. The latter returned an
+    empty body when the caller had no message_id."""
+    resp = MagicMock()
+    resp.code = 0
+    resp.file = _FakeFile(b"\x89PNG-bytes")
+
+    client = MagicMock()
+    client.im.v1.image.get = MagicMock(return_value=resp)
+    client.im.v1.file.get = MagicMock(side_effect=AssertionError("wrong endpoint"))
+    client.im.v1.message_resource.get = MagicMock(
+        side_effect=AssertionError("wrong endpoint")
+    )
+
+    out = await _api_helpers.download_media(
+        client, message_id="", file_key="img_standalone", resource_type="image"
+    )
+    assert out == b"\x89PNG-bytes"
+    client.im.v1.image.get.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_download_file_without_message_id_uses_file_get():
+    resp = MagicMock()
+    resp.code = 0
+    resp.file = _FakeFile(b"%PDF-bytes")
+
+    client = MagicMock()
+    client.im.v1.file.get = MagicMock(return_value=resp)
+    client.im.v1.image.get = MagicMock(side_effect=AssertionError("wrong endpoint"))
+    client.im.v1.message_resource.get = MagicMock(
+        side_effect=AssertionError("wrong endpoint")
+    )
+
+    out = await _api_helpers.download_media(
+        client, message_id="", file_key="file_standalone", resource_type="file"
+    )
+    assert out == b"%PDF-bytes"
+    client.im.v1.file.get.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_download_media_with_message_id_still_uses_message_resource():
+    """Don't regress the message-attachment path: when a message_id IS
+    supplied, the key belongs to a message and must be fetched via
+    ``message_resource.aget`` so the server can authorize it against the
+    conversation."""
+    resp = MagicMock()
+    resp.code = 0
+    resp.file = _FakeFile(b"attachment-bytes")
+
+    client = MagicMock()
+    client.im.v1.message_resource.get = MagicMock(return_value=resp)
+    client.im.v1.image.get = MagicMock(side_effect=AssertionError("wrong endpoint"))
+    client.im.v1.file.get = MagicMock(side_effect=AssertionError("wrong endpoint"))
+
+    out = await _api_helpers.download_media(
+        client,
+        message_id="om_xxx",
+        file_key="file_in_msg",
+        resource_type="file",
+    )
+    assert out == b"attachment-bytes"
+    client.im.v1.message_resource.get.assert_called_once()
diff --git a/lark_channel/channel/tests/test_mentions.py b/lark_channel/channel/tests/test_mentions.py
new file mode 100644
index 0000000..f8347e9
--- /dev/null
+++ b/lark_channel/channel/tests/test_mentions.py
@@ -0,0 +1,108 @@
+"""Tests for mention parsing — node-aligned extract + resolve API."""
+
+from lark_channel.channel.normalize.mentions import (
+    extract_mentions,
+    is_mention_all,
+    parse_at_tags,
+    resolve_mentions,
+    text_has_mention_all,
+)
+
+
+def test_extract_then_resolve_placeholders():
+    text = "hi @_user_1 and @_user_2"
+    events = [
+        {"key": "@_user_1", "id": {"open_id": "ou_A"}, "name": "Alice"},
+        {"key": "@_user_2", "id": {"open_id": "ou_B"}, "name": "Bob"},
+    ]
+    ext = extract_mentions(events)
+    assert ext.mentioned_all is False
+    assert len(ext.mention_list) == 2
+    assert ext.mention_list[0].open_id == "ou_A"
+    assert ext.mentions_by_open_id["ou_A"].name == "Alice"
+
+    out = resolve_mentions(text, ext)
+    assert out == "hi @Alice and @Bob"
+
+
+def test_mention_all_detected_and_excluded():
+    events = [{"key": "@_all", "id": {"user_id": "all"}, "name": "所有人"}]
+    ext = extract_mentions(events)
+    assert ext.mentioned_all is True
+    assert ext.mention_list == []
+    # Unresolved placeholder stays as-is.
+    assert resolve_mentions("@_user_1 hi", ext) == "@_user_1 hi"
+
+
+def test_is_mention_all_detection():
+    assert is_mention_all({"key": "@_all"})
+    assert is_mention_all({"id": {"user_id": "all"}})
+    assert not is_mention_all({"key": "@_user_1", "id": {"user_id": "u1"}})
+
+
+def test_unresolved_placeholder_kept_untouched():
+    ext = extract_mentions([])
+    assert resolve_mentions("hi @_user_9", ext) == "hi @_user_9"
+
+
+def test_strip_bot_mentions_removes_bot_placeholder():
+    events = [
+        {"key": "@_user_1", "id": {"open_id": "ou_bot"}, "name": "Bot"},
+        {"key": "@_user_2", "id": {"open_id": "ou_A"}, "name": "Alice"},
+    ]
+    ext = extract_mentions(events, bot_open_id="ou_bot")
+    assert ext.mentioned_bot is True
+    # Bot excluded from mention_list but kept in `mentions` for strip.
+    assert [m.open_id for m in ext.mention_list] == ["ou_A"]
+    out = resolve_mentions(
+        "hey @_user_1 @_user_2 how are you",
+        ext,
+        strip_bot_mentions=True,
+        bot_open_id="ou_bot",
+    )
+    assert "@_user_1" not in out
+    assert "@Alice" in out
+
+
+def test_parse_at_tags_extracts():
+    ms, all_, stripped = parse_at_tags('hello <at user_id="ou_x">Alice</at>!')
+    assert all_ is False
+    assert "@Alice" in stripped
+    assert len(ms) == 1
+    assert ms[0].open_id == "ou_x"
+    assert ms[0].name == "Alice"
+
+
+def test_parse_at_tags_mentioned_all():
+    ms, all_, stripped = parse_at_tags('<at user_id="all">everyone</at> notice')
+    assert all_ is True
+    assert "@all" in stripped
+    assert ms == []
+
+
+# ---------------------------------------------------------------------------
+# Regression: Feishu ships mention-all as a bare ``@_all`` token in text
+# content with ``mentions=null``. Detection must come from the text, not
+# just the mentions array.
+# ---------------------------------------------------------------------------
+
+
+def test_text_has_mention_all_detects_bare_token():
+    assert text_has_mention_all("@_all please ack") is True
+    assert text_has_mention_all("prefix @_all suffix") is True
+    assert text_has_mention_all("@_all") is True
+
+
+def test_text_has_mention_all_false_for_non_token_substring():
+    # Guard against false positives where ``@_all`` is a prefix of a
+    # different identifier.
+    assert text_has_mention_all("@_all_employees please ack") is False
+    assert text_has_mention_all("@_allhands meeting") is False
+    assert text_has_mention_all("") is False
+    assert text_has_mention_all(None) is False
+
+
+def test_resolve_mentions_rewrites_at_all_placeholder():
+    """User-visible content shouldn't leak the raw ``@_all`` token."""
+    result = resolve_mentions("@_all hi", extract_mentions([]))
+    assert result == "@all hi"
diff --git a/lark_channel/channel/tests/test_merge_forward.py b/lark_channel/channel/tests/test_merge_forward.py
new file mode 100644
index 0000000..f5a73d7
--- /dev/null
+++ b/lark_channel/channel/tests/test_merge_forward.py
@@ -0,0 +1,87 @@
+"""merge_forward expansion tests (success + failure + depth limit)."""
+
+import json
+
+import pytest
+
+from lark_channel.channel.normalize.merge_forward import MergeForwardExpander
+from lark_channel.channel.types import MergeForwardContent, TextContent
+
+
+def _child(mid, text, sender_id="ou_a"):
+    return {
+        "message_id": mid,
+        "msg_type": "text",
+        "body": {"content": json.dumps({"text": text})},
+        "sender": {"id": sender_id},
+        "create_time": "100",
+    }
+
+
+@pytest.mark.asyncio
+async def test_expand_success():
+    async def fetch(mid):
+        return {"data": {"items": [
+            {"message_id": mid, "msg_type": "merge_forward", "body": {"content": "{}"}},
+            _child("c1", "hello"),
+            _child("c2", "world", sender_id="ou_b"),
+        ]}}
+
+    async def names(ids):
+        return {i: f"Name-{i}" for i in ids}
+
+    exp = MergeForwardExpander(fetch_message=fetch, resolve_names=names)
+    res = await exp.expand("om_root")
+    assert isinstance(res, MergeForwardContent)
+    assert len(res.items) == 2
+    assert res.items[0].sender_name == "Name-ou_a"
+    assert isinstance(res.items[0].content, TextContent)
+    assert res.items[0].content.text == "hello"
+
+
+@pytest.mark.asyncio
+async def test_expand_truncates():
+    async def fetch(mid):
+        return {"data": {"items": [
+            {"message_id": mid, "msg_type": "merge_forward", "body": {"content": "{}"}},
+            *[_child(f"c{i}", f"msg{i}") for i in range(10)],
+        ]}}
+
+    exp = MergeForwardExpander(fetch_message=fetch, max_items=3)
+    res = await exp.expand("om_root")
+    assert res.truncated is True
+    assert len(res.items) == 3
+
+
+@pytest.mark.asyncio
+async def test_expand_error_on_fetch_failure():
+    async def fetch(mid):
+        raise RuntimeError("network down")
+
+    exp = MergeForwardExpander(fetch_message=fetch)
+    res = await exp.expand("om_root")
+    assert res.loading is False
+    assert res.error and "network down" in res.error
+    assert res.items == []
+
+
+@pytest.mark.asyncio
+async def test_empty_payload_error():
+    async def fetch(mid):
+        return None
+
+    exp = MergeForwardExpander(fetch_message=fetch)
+    res = await exp.expand("om_root")
+    assert res.error == "empty_payload"
+
+
+@pytest.mark.asyncio
+async def test_depth_limit():
+    async def fetch(mid):
+        return {"data": {"items": [
+            {"message_id": mid, "msg_type": "merge_forward", "body": {"content": "{}"}},
+        ]}}
+
+    exp = MergeForwardExpander(fetch_message=fetch, max_depth=0)
+    res = await exp.expand("om_root", depth=1)
+    assert res.error == "max_depth_exceeded"
diff --git a/lark_channel/channel/tests/test_merge_forward_node_aligned_flow.py b/lark_channel/channel/tests/test_merge_forward_node_aligned_flow.py
new file mode 100644
index 0000000..fd37fea
--- /dev/null
+++ b/lark_channel/channel/tests/test_merge_forward_node_aligned_flow.py
@@ -0,0 +1,189 @@
+"""Regression: merge_forward expands in ONE fetch + local tree traversal.
+
+Covers the alignment fix that replaced per-nested-forward re-fetching with
+node-sdk's ``buildChildrenMap``/``formatSubTree`` pattern (commit ccc7e31's
+channel/normalize/converters/merge-forward.ts).
+
+The invariant this file protects: no matter how deeply nested the forward
+tree, ``expand()`` performs exactly ONE ``fetch_message`` call. Nested
+forwards are materialized from the same flat items list via
+``upper_message_id`` parent links.
+"""
+
+import json
+
+import pytest
+
+from lark_channel.channel.normalize.merge_forward import MergeForwardExpander
+from lark_channel.channel.types import (
+    MergeForwardContent,
+    TextContent,
+)
+
+
+def _child(mid, text, upper=None, sender_id="ou_a"):
+    it = {
+        "message_id": mid,
+        "msg_type": "text",
+        "body": {"content": json.dumps({"text": text})},
+        "sender": {"id": sender_id},
+        "create_time": "100",
+    }
+    if upper:
+        it["upper_message_id"] = upper
+    return it
+
+
+def _nested_mf(mid, upper=None):
+    it = {
+        "message_id": mid,
+        "msg_type": "merge_forward",
+        "body": {"content": "{}"},
+        "sender": {"id": "ou_x"},
+        "create_time": "50",
+    }
+    if upper:
+        it["upper_message_id"] = upper
+    return it
+
+
+@pytest.mark.asyncio
+async def test_single_fetch_for_deeply_nested_tree():
+    """Even with 3 levels of nested merge_forward, ``expand()`` fetches once."""
+    fetch_calls = []
+
+    async def fetch(mid):
+        fetch_calls.append(mid)
+        # Flat list: root → mf_l1 → mf_l2 → text leaf.
+        return {"data": {"items": [
+            {"message_id": "root", "msg_type": "merge_forward", "body": {"content": "{}"}},
+            _nested_mf("mf_l1", upper="root"),
+            _nested_mf("mf_l2", upper="mf_l1"),
+            _child("leaf", "deep hello", upper="mf_l2"),
+        ]}}
+
+    exp = MergeForwardExpander(fetch_message=fetch)
+    res = await exp.expand("root")
+
+    # Exactly ONE fetch — critical divergence from the pre-fix behavior.
+    assert fetch_calls == ["root"], f"expected 1 fetch, got {fetch_calls}"
+
+    # Tree shape: root has 1 child (mf_l1), which has 1 child (mf_l2), which has leaf.
+    assert len(res.items) == 1
+    lvl1 = res.items[0].content
+    assert isinstance(lvl1, MergeForwardContent)
+    assert len(lvl1.items) == 1
+    lvl2 = lvl1.items[0].content
+    assert isinstance(lvl2, MergeForwardContent)
+    assert len(lvl2.items) == 1
+    leaf = lvl2.items[0].content
+    assert isinstance(leaf, TextContent)
+    assert leaf.text == "deep hello"
+
+
+@pytest.mark.asyncio
+async def test_items_without_upper_message_id_default_to_root_parent():
+    """Legacy payloads (no upper_message_id) still work — items attach to root."""
+    async def fetch(mid):
+        return {"data": {"items": [
+            {"message_id": mid, "msg_type": "merge_forward", "body": {"content": "{}"}},
+            _child("c1", "hello"),
+            _child("c2", "world", sender_id="ou_b"),
+        ]}}
+
+    exp = MergeForwardExpander(fetch_message=fetch)
+    res = await exp.expand("om_root")
+    assert len(res.items) == 2
+    assert isinstance(res.items[0].content, TextContent)
+    assert res.items[0].content.text == "hello"
+
+
+@pytest.mark.asyncio
+async def test_sender_names_batched_once_for_whole_tree():
+    """All sender open_ids across depths should be batch-resolved in one call."""
+    batch_calls = []
+
+    async def fetch(mid):
+        return {"data": {"items": [
+            {"message_id": "root", "msg_type": "merge_forward", "body": {"content": "{}"}},
+            _nested_mf("mf_l1", upper="root"),
+            _child("c_top", "top", upper="root", sender_id="ou_top"),
+            _child("c_nested_1", "n1", upper="mf_l1", sender_id="ou_n1"),
+            _child("c_nested_2", "n2", upper="mf_l1", sender_id="ou_n2"),
+        ]}}
+
+    async def names(ids):
+        batch_calls.append(sorted(ids))
+        return {i: f"Name-{i}" for i in ids}
+
+    exp = MergeForwardExpander(fetch_message=fetch, resolve_names=names)
+    res = await exp.expand("root")
+
+    assert len(batch_calls) == 1
+    ids = batch_calls[0]
+    assert "ou_top" in ids and "ou_n1" in ids and "ou_n2" in ids and "ou_x" in ids
+    # Names applied to both the top item and items inside the nested forward.
+    top_item = next(it for it in res.items if it.sender_open_id == "ou_top")
+    assert top_item.sender_name == "Name-ou_top"
+    nested_content = next(
+        it for it in res.items if isinstance(it.content, MergeForwardContent)
+    ).content
+    nested_names = {i.sender_name for i in nested_content.items}
+    assert nested_names == {"Name-ou_n1", "Name-ou_n2"}
+
+
+@pytest.mark.asyncio
+async def test_placeholder_in_nested_child_resolves_via_top_mentions():
+    """Node resolves ``@_user_N`` found in forwarded child content against the
+    OUTER message's mentions map (via the single-pass ``resolveMentions`` on the
+    final rendered text). Python's pipeline mirrors this with a second-pass
+    ``resolve_mentions`` on ``flat_text`` — this test pins that behavior.
+    """
+    # Build a fake message_event shape the pipeline accepts. Child text
+    # contains a @_user_1 placeholder; outer mentions array carries the entry.
+    from types import SimpleNamespace
+
+    from lark_channel.channel.normalize.pipeline import (
+        InboundPipeline,
+        PipelineConfig,
+        PipelineDeps,
+    )
+
+    async def fetch_message(mid):
+        # The outer merge_forward root + one child whose text has a placeholder.
+        return {"data": {"items": [
+            {"message_id": "om_root", "msg_type": "merge_forward", "body": {"content": "{}"}},
+            _child("c_placeholder", "ping @_user_1 wake up", upper="om_root"),
+        ]}}
+
+    cfg = PipelineConfig()
+    cfg.inbound.expand_merge_forward = True
+    deps = PipelineDeps(fetch_message=fetch_message)
+    pipe = InboundPipeline(cfg=cfg, deps=deps)
+
+    message_event = SimpleNamespace(
+        message_id="om_root",
+        root_id="",
+        parent_id="",
+        create_time="0",
+        chat_id="oc_1",
+        thread_id=None,
+        chat_type="group",
+        message_type="merge_forward",
+        content="{}",
+        mentions=[
+            {"key": "@_user_1", "id": {"open_id": "ou_alice"}, "name": "Alice"},
+        ],
+        user_agent=None,
+    )
+    sender = SimpleNamespace(
+        sender_id=SimpleNamespace(open_id="ou_sender", user_id=None, union_id=None),
+        sender_type="user",
+    )
+    inbound = await pipe.process(
+        event_id="e1", message_event=message_event, sender=sender,
+    )
+    assert inbound is not None
+    # Placeholder inside the forwarded child text must be resolved to @Alice.
+    assert "@Alice" in inbound.content_text
+    assert "@_user_1" not in inbound.content_text
diff --git a/lark_channel/channel/tests/test_outbound_capabilities_and_event_forwarding.py b/lark_channel/channel/tests/test_outbound_capabilities_and_event_forwarding.py
new file mode 100644
index 0000000..d4af65b
--- /dev/null
+++ b/lark_channel/channel/tests/test_outbound_capabilities_and_event_forwarding.py
@@ -0,0 +1,229 @@
+"""Outbound share/sticker coercion plus error and reject event forwarding."""
+
+import asyncio
+from unittest.mock import AsyncMock
+
+import pytest
+
+from lark_channel.channel import (
+    FeishuChannel,
+    OutboundShareChat,
+    OutboundShareUser,
+    OutboundSticker,
+)
+from lark_channel.channel._coerce import coerce_outbound
+from lark_channel.channel.safety import SafetyPipeline
+from lark_channel.channel.types import (
+    Conversation,
+    Identity,
+    InboundMessage,
+    SendError,
+    TextContent,
+)
+from lark_channel.channel.errors import FeishuChannelErrorCode, OutboundSendError
+
+
+# ---------------------------------------------------------------------------
+# Outbound share_chat / share_user / sticker coercion.
+# ---------------------------------------------------------------------------
+
+
+def test_coerce_share_chat_dict():
+    out = coerce_outbound({"share_chat": {"chat_id": "oc_xyz"}})
+    assert isinstance(out, OutboundShareChat)
+    assert out.chat_id == "oc_xyz"
+
+
+def test_coerce_share_chat_camelcase_and_string_shorthand():
+    # camelCase key for cross-language JSON compatibility.
+    assert coerce_outbound({"shareChat": {"chatId": "oc_cam"}}).chat_id == "oc_cam"
+    # Bare string shorthand: ``{"share_chat": "oc_..."}`` → same thing.
+    assert coerce_outbound({"share_chat": "oc_bare"}).chat_id == "oc_bare"
+
+
+def test_coerce_share_user_dict():
+    out = coerce_outbound({"share_user": {"user_id": "ou_xyz"}})
+    assert isinstance(out, OutboundShareUser)
+    assert out.user_id == "ou_xyz"
+
+
+def test_coerce_share_user_accepts_open_id_alias():
+    # On the wire Feishu calls this field ``user_id`` but Python users
+    # usually hold an ``open_id`` in hand; both accepted for ergonomics.
+    assert coerce_outbound({"share_user": {"open_id": "ou_open"}}).user_id == "ou_open"
+
+
+def test_coerce_sticker_dict():
+    out = coerce_outbound({"sticker": {"file_key": "img_key_123"}})
+    assert isinstance(out, OutboundSticker)
+    assert out.file_key == "img_key_123"
+
+
+def test_coerce_sticker_string_shorthand():
+    assert coerce_outbound({"sticker": "img_key_abc"}).file_key == "img_key_abc"
+
+
+@pytest.mark.asyncio
+async def test_send_share_chat_wire_format():
+    """End-to-end: ``channel.send(to, {"share_chat": ...})`` must produce a
+    Feishu ``msg_type=share_chat`` wire body with ``content={"chat_id": ...}``
+    (JSON-encoded). Patch the sender's ``SendDriver`` directly — monkey-
+    patching ``channel._driver.create_message`` as an instance attribute
+    does NOT propagate because ``OutboundSender`` captured the bound
+    method at construction time."""
+    import json
+    ch = FeishuChannel(app_id="cli_x", app_secret="s")
+    ch._sender._driver.create_message = AsyncMock(  # type: ignore[attr-defined]
+        return_value={"code": 0, "data": {"message_id": "om_sent"}}
+    )
+    result = await ch.send("oc_target", {"share_chat": {"chat_id": "oc_src"}})
+    assert result.success is True
+    assert result.message_id == "om_sent"
+    call = ch._sender._driver.create_message.call_args
+    body = call.kwargs
+    assert body["msg_type"] == "share_chat"
+    assert json.loads(body["content"]) == {"chat_id": "oc_src"}
+
+
+@pytest.mark.asyncio
+async def test_send_sticker_wire_format():
+    import json
+    ch = FeishuChannel(app_id="cli_x", app_secret="s")
+    ch._sender._driver.create_message = AsyncMock(
+        return_value={"code": 0, "data": {"message_id": "om_sticker"}}
+    )
+    result = await ch.send("oc_target", {"sticker": {"file_key": "img_k"}})
+    assert result.success is True
+    call = ch._sender._driver.create_message.call_args
+    body = call.kwargs
+    assert body["msg_type"] == "sticker"
+    assert json.loads(body["content"]) == {"file_key": "img_k"}
+
+
+# ---------------------------------------------------------------------------
+# on("error") receives send/stream failures.
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_send_failure_forwarded_to_on_error():
+    """When ``channel.send()`` returns a ``SendResult.fail(...)``, any
+    handler registered via ``on("error", ...)`` must also see the error.
+    The original ``SendResult`` is still returned to the caller — forwarding
+    does not swallow."""
+    ch = FeishuChannel(app_id="cli_x", app_secret="s")
+    seen = []
+    ch.on("error", lambda e: seen.append(e))
+
+    # Driver returns a rate-limit code → sender retries + eventually returns
+    # SendResult.fail(RATE_LIMITED, ...). Patch on the SendDriver seam the
+    # sender actually captured.
+    ch._sender._driver.create_message = AsyncMock(  # type: ignore[attr-defined]
+        return_value={"code": 11020, "msg": "rate limited"}
+    )
+    # Tighten retry so the test is quick.
+    ch._sender._config.retry.max_attempts = 1  # type: ignore[attr-defined]
+    ch._sender._config.retry.base_delay_ms = 1  # type: ignore[attr-defined]
+
+    result = await ch.send("oc_x", {"text": "hi"})
+    assert result.success is False
+    assert result.error is not None
+    assert result.error.code == FeishuChannelErrorCode.RATE_LIMITED
+    # Direct caller still sees the SendError dataclass via result.error.
+    assert isinstance(result.error, SendError)
+    # Forwarded — handlers receive an Exception subclass so generic
+    # diagnostic tooling (logger.exception, traceback formatting, Sentry)
+    # works uniformly. The original SendError is preserved at .send_error.
+    assert len(seen) == 1
+    assert isinstance(seen[0], OutboundSendError)
+    assert isinstance(seen[0], Exception)
+    assert seen[0].code == FeishuChannelErrorCode.RATE_LIMITED
+    assert seen[0].send_error is result.error
+    assert seen[0].retryable is True
+    assert seen[0].raw_code == 11020
+
+
+@pytest.mark.asyncio
+async def test_send_raised_exception_forwarded_to_on_error():
+    """Even exceptions raised synchronously during coerce (e.g. unknown
+    input shape) must be forwarded before the re-raise."""
+    ch = FeishuChannel(app_id="cli_x", app_secret="s")
+    seen = []
+    ch.on("error", lambda e: seen.append(e))
+
+    with pytest.raises(TypeError):
+        await ch.send("oc_x", {"no_such_key": "oops"})
+
+    assert len(seen) == 1
+    assert isinstance(seen[0], TypeError)
+
+
+# ---------------------------------------------------------------------------
+# RejectEvent emission on dedup / stale hits.
+# ---------------------------------------------------------------------------
+
+
+def _inbound(msg_id: str, *, create_time: int = 1_000_000_000_000) -> InboundMessage:
+    return InboundMessage(
+        id=msg_id,
+        create_time=create_time,
+        conversation=Conversation(chat_id="oc_x", chat_type="p2p"),
+        sender=Identity(open_id="ou_sender"),
+        content=TextContent(text="hi"),
+    )
+
+
+@pytest.mark.asyncio
+async def test_duplicate_emits_reject_event():
+    """Feeding the same message_id twice through SafetyPipeline's full
+    tier must emit ``RejectEvent(reason="duplicate")`` on the second hit
+    (before: silent drop).
+
+    Disables the per-chat queue so the first ``push_message`` synchronously
+    runs through handler → ``seen.add`` before returning — otherwise the
+    dedup mark would be set inside a later batch flush and the second
+    push wouldn't see it.
+    """
+    from lark_channel.channel.config import ChatQueueConfig
+    import time
+
+    loop = asyncio.get_running_loop()
+    rejects = []
+    dispatched = []
+
+    async def on_msg(m):
+        dispatched.append(m)
+
+    sp = SafetyPipeline(
+        loop=loop,
+        on_message=on_msg,
+        on_reject=lambda e: rejects.append(e),
+        queue_config=ChatQueueConfig(enabled=False),
+    )
+    msg = _inbound("om_dup", create_time=int(time.time() * 1000))
+    await sp.push_message(msg)
+    assert len(dispatched) == 1, "first push should dispatch"
+    await sp.push_message(msg)  # duplicate
+    assert any(
+        r.reason == "duplicate" and r.message_id == "om_dup" for r in rejects
+    ), f"expected a 'duplicate' RejectEvent, got {rejects}"
+
+
+@pytest.mark.asyncio
+async def test_stale_emits_reject_event():
+    """A message with ``create_time`` older than the stale window must emit
+    ``RejectEvent(reason="stale")`` (before: silent drop)."""
+    loop = asyncio.get_running_loop()
+    rejects = []
+    sp = SafetyPipeline(
+        loop=loop,
+        on_message=lambda m: asyncio.sleep(0),
+        on_reject=lambda e: rejects.append(e),
+        stale_window_ms=1,  # almost everything counts as stale
+    )
+    # A create_time from well in the past → definitely stale.
+    msg = _inbound("om_stale", create_time=1)
+    await sp.push_message(msg)
+    assert any(
+        r.reason == "stale" and r.message_id == "om_stale" for r in rejects
+    ), f"expected a 'stale' RejectEvent, got {rejects}"
diff --git a/lark_channel/channel/tests/test_outbound_wire_contract.py b/lark_channel/channel/tests/test_outbound_wire_contract.py
new file mode 100644
index 0000000..e364236
--- /dev/null
+++ b/lark_channel/channel/tests/test_outbound_wire_contract.py
@@ -0,0 +1,160 @@
+"""Byte-level contract tests for the outbound ``_build_*`` helpers.
+
+These tests assert the EXACT JSON shape Feishu's
+``POST /open-apis/im/v1/messages`` expects for each ``msg_type``. They are
+designed to catch a class of bug where Python's SDK produces structurally
+plausible output but wraps or key-names differ from what the server accepts
+— e.g. the 2024 ``230001 invalid message content`` incident caused by
+wrapping post content with an extra ``{"post": ...}`` envelope.
+
+Reference shapes (verified against Feishu OpenAPI docs + node-sdk):
+
+    text       → ``{"text": "..."}``
+    post       → ``{"<locale>": {"title": "...", "content": [[...]]}}``  (NO outer "post")
+    interactive→ card JSON as-is   OR  ``{"type": "card", "data": {"card_id": "..."}}``
+    image      → ``{"image_key": "..."}``
+    file       → ``{"file_key": "..."}``
+    audio      → ``{"file_key": "..."}``
+    media      → ``{"file_key": "..."}``  (msg_type is "media", not "video")
+"""
+
+import json
+
+from lark_channel.channel.outbound.sender import (
+    _build_audio,
+    _build_card,
+    _build_file,
+    _build_image,
+    _build_post,
+    _build_text,
+    _build_video,
+    _post_to_plain_text_from_body,
+)
+from lark_channel.channel.types import (
+    Identity,
+    OutboundCard,
+    OutboundPost,
+    OutboundText,
+)
+
+
+# ---------------------------------------------------------------------------
+# text
+# ---------------------------------------------------------------------------
+
+
+def test_text_wire_shape_is_bare_text_object():
+    body = _build_text(OutboundText(text="hello"))
+    assert body["msg_type"] == "text"
+    parsed = json.loads(body["content"])
+    assert parsed == {"text": "hello"}
+
+
+def test_text_wire_mention_prepends_at_tag():
+    body = _build_text(
+        OutboundText(
+            text="ping",
+            mentions=[Identity(open_id="ou_alice", display_name="Alice")],
+        )
+    )
+    parsed = json.loads(body["content"])
+    # `<at user_id="ou_alice">Alice</at> ping`
+    assert parsed["text"].startswith('<at user_id="ou_alice">Alice</at>')
+    assert parsed["text"].endswith("ping")
+
+
+# ---------------------------------------------------------------------------
+# post — the shape that caused 230001 in production
+# ---------------------------------------------------------------------------
+
+
+def test_post_content_is_locale_map_not_wrapped():
+    body = _build_post(OutboundPost(markdown="**bold**"))
+    assert body["msg_type"] == "post"
+    parsed = json.loads(body["content"])
+    # REGRESSION: Feishu API rejects content wrapped as {"post": {...}}.
+    # Correct shape is the locale-keyed map directly at the root.
+    assert "post" not in parsed, (
+        f"post content must NOT be wrapped in {{'post': ...}}; got keys {list(parsed)}"
+    )
+    assert "zh_cn" in parsed
+    assert "title" in parsed["zh_cn"]
+    assert "content" in parsed["zh_cn"]
+    assert isinstance(parsed["zh_cn"]["content"], list)
+    assert isinstance(parsed["zh_cn"]["content"][0], list)
+
+
+def test_post_with_prebuilt_ast_not_wrapped():
+    ast = {
+        "zh_cn": {
+            "title": "hello",
+            "content": [[{"tag": "text", "text": "world"}]],
+        }
+    }
+    body = _build_post(OutboundPost(post=ast))
+    parsed = json.loads(body["content"])
+    assert parsed == ast  # exact equality — not wrapped
+
+
+def test_post_empty_still_unwrapped():
+    body = _build_post(OutboundPost(title="x"))
+    parsed = json.loads(body["content"])
+    assert "post" not in parsed
+    assert parsed["zh_cn"]["title"] == "x"
+
+
+def test_post_body_plain_text_fallback_reads_unwrapped_shape():
+    # Simulates the format_error → plain-text downgrade path.
+    body = _build_post(OutboundPost(markdown="**hi**"))
+    plain = _post_to_plain_text_from_body(body["content"])
+    # Round-trip through the fallback recovers the text — proving it reads
+    # the same unwrapped shape that _build_post emits.
+    assert "hi" in plain
+
+
+# ---------------------------------------------------------------------------
+# card (interactive)
+# ---------------------------------------------------------------------------
+
+
+def test_card_raw_card_shape_passthrough():
+    raw = {"schema": "2.0", "body": {"elements": [{"tag": "markdown", "content": "x"}]}}
+    body = _build_card(OutboundCard(card=raw))
+    assert body["msg_type"] == "interactive"
+    assert json.loads(body["content"]) == raw
+
+
+def test_card_by_id_shape_is_type_card_data_card_id():
+    body = _build_card(OutboundCard(card_id="cd_abc"))
+    assert body["msg_type"] == "interactive"
+    assert json.loads(body["content"]) == {"type": "card", "data": {"card_id": "cd_abc"}}
+
+
+# ---------------------------------------------------------------------------
+# media builders
+# ---------------------------------------------------------------------------
+
+
+def test_image_shape_is_image_key_only():
+    body = _build_image("img_abc")
+    assert body["msg_type"] == "image"
+    assert json.loads(body["content"]) == {"image_key": "img_abc"}
+
+
+def test_file_shape_is_file_key_only():
+    body = _build_file("file_abc")
+    assert body["msg_type"] == "file"
+    assert json.loads(body["content"]) == {"file_key": "file_abc"}
+
+
+def test_audio_shape_is_file_key_only():
+    body = _build_audio("file_audio")
+    assert body["msg_type"] == "audio"
+    assert json.loads(body["content"]) == {"file_key": "file_audio"}
+
+
+def test_video_uses_media_msg_type_and_file_key():
+    # Feishu distinguishes video upload via msg_type="media".
+    body = _build_video("file_video")
+    assert body["msg_type"] == "media"
+    assert json.loads(body["content"]) == {"file_key": "file_video"}
diff --git a/lark_channel/channel/tests/test_oversize_hook.py b/lark_channel/channel/tests/test_oversize_hook.py
new file mode 100644
index 0000000..b9ec5a9
--- /dev/null
+++ b/lark_channel/channel/tests/test_oversize_hook.py
@@ -0,0 +1,143 @@
+"""Tests for the OutboundConfig.on_oversize hook."""
+
+import pytest
+
+from lark_channel.channel import OutboundConfig, OversizeContext
+
+
+def test_on_oversize_default_is_none():
+    cfg = OutboundConfig()
+    assert cfg.on_oversize is None
+
+
+def test_on_oversize_accepts_callable():
+    async def hook(ctx: OversizeContext):
+        return None
+    cfg = OutboundConfig(on_oversize=hook)
+    assert cfg.on_oversize is hook
+
+
+def test_oversize_context_fields():
+    ctx = OversizeContext(
+        text="...",
+        chat_id="oc_x",
+        receive_id_type="chat_id",
+        estimated_chunks=5,
+    )
+    assert ctx.text == "..."
+    assert ctx.chat_id == "oc_x"
+    assert ctx.receive_id_type == "chat_id"
+    assert ctx.estimated_chunks == 5
+
+
+# --- Integration: hook is invoked before chunking ------------------------
+
+from lark_channel.channel import FeishuChannel
+
+
+def _make_channel_with_hook(hook):
+    """Build a channel whose driver is a no-op send that captures payloads."""
+    cfg = OutboundConfig(text_chunk_limit=20, on_oversize=hook)
+    ch = FeishuChannel(app_id="cli_x", app_secret="x", outbound=cfg)
+    return ch
+
+
+@pytest.mark.asyncio
+async def test_hook_returns_replacement_sends_one_message(monkeypatch):
+    """When hook returns non-empty, exactly one send call carries the replacement."""
+    captured = []
+
+    async def fake_create(*args, **kwargs):
+        captured.append(kwargs.get("content") or args)
+        return {"code": 0, "data": {"message_id": "om_1"}}
+
+    async def hook(ctx: OversizeContext):
+        return f"long content: see {ctx.estimated_chunks} chunks at /paste/abc"
+
+    ch = _make_channel_with_hook(hook)
+    monkeypatch.setattr(ch._sender._driver, "create_message", fake_create)
+
+    long_text = "x" * 200  # 10x the chunk limit, would normally split into ~10
+    result = await ch.send("oc_x", {"text": long_text})
+
+    assert result.success
+    assert len(captured) == 1
+    payload = captured[0]
+    assert "/paste/abc" in str(payload)
+    assert "x" * 100 not in str(payload)
+
+
+@pytest.mark.asyncio
+async def test_hook_returns_none_falls_back_to_chunks(monkeypatch):
+    """When hook returns None, SDK chunks normally and sends multiple messages."""
+    captured = []
+
+    async def fake_create(*args, **kwargs):
+        captured.append(kwargs.get("content") or args)
+        return {"code": 0, "data": {"message_id": f"om_{len(captured)}"}}
+
+    async def hook(ctx):
+        return None
+
+    ch = _make_channel_with_hook(hook)
+    monkeypatch.setattr(ch._sender._driver, "create_message", fake_create)
+
+    long_text = "x" * 200
+    await ch.send("oc_x", {"text": long_text})
+
+    # 200 chars at limit=20 yields >1 chunk
+    assert len(captured) > 1
+
+
+@pytest.mark.asyncio
+async def test_hook_returns_empty_string_falls_back(monkeypatch):
+    captured = []
+
+    async def fake_create(*args, **kwargs):
+        captured.append(kwargs)
+        return {"code": 0, "data": {"message_id": "om_1"}}
+
+    async def hook(ctx):
+        return ""
+
+    ch = _make_channel_with_hook(hook)
+    monkeypatch.setattr(ch._sender._driver, "create_message", fake_create)
+    await ch.send("oc_x", {"text": "x" * 200})
+    assert len(captured) > 1
+
+
+@pytest.mark.asyncio
+async def test_hook_raises_propagates_no_fallback(monkeypatch):
+    sent = []
+
+    async def fake_create(*args, **kwargs):
+        sent.append(kwargs)
+        return {"code": 0}
+
+    async def hook(ctx):
+        raise RuntimeError("paste.rs unavailable")
+
+    ch = _make_channel_with_hook(hook)
+    monkeypatch.setattr(ch._sender._driver, "create_message", fake_create)
+
+    with pytest.raises(RuntimeError, match="paste.rs unavailable"):
+        await ch.send("oc_x", {"text": "x" * 200})
+    # Crucially, no chunked send happened either:
+    assert sent == []
+
+
+@pytest.mark.asyncio
+async def test_short_text_does_not_invoke_hook(monkeypatch):
+    invocations = []
+
+    async def hook(ctx):
+        invocations.append(ctx)
+        return None
+
+    async def fake_create(*args, **kwargs):
+        return {"code": 0, "data": {"message_id": "om_1"}}
+
+    ch = _make_channel_with_hook(hook)
+    monkeypatch.setattr(ch._sender._driver, "create_message", fake_create)
+    await ch.send("oc_x", {"text": "short"})
+    assert invocations == []
diff --git a/lark_channel/channel/tests/test_parser.py b/lark_channel/channel/tests/test_parser.py
new file mode 100644
index 0000000..7fed40f
--- /dev/null
+++ b/lark_channel/channel/tests/test_parser.py
@@ -0,0 +1,151 @@
+"""Tests for the sync message-content parser."""
+
+import json
+
+from lark_channel.channel.normalize.registry import SUPPORTED_MESSAGE_TYPES, parse_message_content
+from lark_channel.channel.types import (
+    AudioContent,
+    CalendarContent,
+    FileContent,
+    ImageContent,
+    InteractiveContent,
+    LocationContent,
+    MediaContent,
+    MergeForwardContent,
+    PostContent,
+    ShareChatContent,
+    ShareUserContent,
+    StickerContent,
+    SystemContent,
+    TextContent,
+    TodoContent,
+    UnknownContent,
+    VideoChatContent,
+    VoteContent,
+)
+
+
+def _c(d):
+    return json.dumps(d, ensure_ascii=False)
+
+
+def test_text():
+    c = parse_message_content("text", _c({"text": "hello @_user_1"}))
+    assert isinstance(c, TextContent)
+    assert c.text == "hello @_user_1"
+
+
+def test_post_flattens_text_and_title():
+    post = {
+        "zh_cn": {
+            "title": "晴报",
+            "content": [
+                [{"tag": "text", "text": "hello "}, {"tag": "a", "text": "link", "href": "https://x"}],
+                [{"tag": "at", "user_id": "ou_1", "user_name": "张三"}, {"tag": "text", "text": " 你好"}],
+            ],
+        }
+    }
+    c = parse_message_content("post", _c(post))
+    assert isinstance(c, PostContent)
+    assert c.title == "晴报"
+    assert "hello link" in c.text
+    assert "@张三 你好" in c.text
+
+
+def test_image():
+    c = parse_message_content("image", _c({"image_key": "img_xxx"}))
+    assert isinstance(c, ImageContent) and c.image_key == "img_xxx"
+
+
+def test_file_has_name():
+    c = parse_message_content("file", _c({"file_key": "f_xxx", "file_name": "a.pdf"}))
+    assert isinstance(c, FileContent)
+    assert c.file_key == "f_xxx"
+    assert c.file_name == "a.pdf"
+
+
+def test_audio_duration():
+    c = parse_message_content("audio", _c({"file_key": "a_xxx", "duration": 3200}))
+    assert isinstance(c, AudioContent) and c.duration_ms == 3200
+
+
+def test_media_with_cover():
+    c = parse_message_content(
+        "media", _c({"file_key": "v_x", "image_key": "cover_x", "duration": 5000})
+    )
+    assert isinstance(c, MediaContent)
+    assert c.file_key == "v_x" and c.image_key == "cover_x"
+
+
+def test_sticker():
+    c = parse_message_content("sticker", _c({"file_key": "st"}))
+    assert isinstance(c, StickerContent)
+
+
+def test_interactive_v1_detect():
+    c = parse_message_content("interactive", _c({"elements": [], "config": {}}))
+    assert isinstance(c, InteractiveContent) and c.card_version == "v1"
+
+
+def test_interactive_v2_detect():
+    c = parse_message_content("interactive", _c({"schema": "2.0", "body": {"elements": []}}))
+    assert isinstance(c, InteractiveContent) and c.card_version == "v2"
+
+
+def test_share_chat_user_system_location():
+    assert isinstance(parse_message_content("share_chat", _c({"chat_id": "oc_1"})), ShareChatContent)
+    assert isinstance(parse_message_content("share_user", _c({"user_id": "ou_1"})), ShareUserContent)
+    assert isinstance(parse_message_content("system", _c({"template": "add"})), SystemContent)
+    loc = parse_message_content("location", _c({"name": "office", "longitude": "116.4", "latitude": "39.9"}))
+    assert isinstance(loc, LocationContent)
+    assert loc.longitude == 116.4 and loc.latitude == 39.9
+
+
+def test_video_calendar_vote_todo():
+    assert isinstance(parse_message_content("video_chat", _c({"topic": "sync"})), VideoChatContent)
+    assert isinstance(parse_message_content("calendar", _c({"summary": "mtg"})), CalendarContent)
+    v = parse_message_content("vote", _c({"topic": "q", "options": ["a", "b"]}))
+    assert isinstance(v, VoteContent) and v.options == ["a", "b"]
+    assert isinstance(parse_message_content("todo", _c({"summary": "task"})), TodoContent)
+
+
+def test_merge_forward_is_loading():
+    c = parse_message_content("merge_forward", _c({}))
+    assert isinstance(c, MergeForwardContent) and c.loading is True
+
+
+def test_unknown_fallback():
+    c = parse_message_content("brand_new_type", _c({"x": 1}))
+    assert isinstance(c, UnknownContent) and c.message_type == "brand_new_type"
+
+
+def test_bad_json_does_not_raise():
+    c = parse_message_content("text", "{{{ not json")
+    assert isinstance(c, TextContent) and c.text == ""
+
+
+def test_supported_covers_19_types():
+    # 17 sync-parseable + interactive + merge_forward (post-merge with interactive placeholder)
+    # The design doc lists 19 message formats. Check we support at least the
+    # 17 types the parser handles plus interactive + merge_forward.
+    assert len(SUPPORTED_MESSAGE_TYPES) == 22
+    for t in (
+        "text",
+        "post",
+        "image",
+        "file",
+        "audio",
+        "media",
+        "sticker",
+        "interactive",
+        "share_chat",
+        "share_user",
+        "system",
+        "location",
+        "video_chat",
+        "calendar",
+        "vote",
+        "todo",
+        "merge_forward",
+    ):
+        assert t in SUPPORTED_MESSAGE_TYPES
diff --git a/lark_channel/channel/tests/test_pipeline.py b/lark_channel/channel/tests/test_pipeline.py
new file mode 100644
index 0000000..ce77cd0
--- /dev/null
+++ b/lark_channel/channel/tests/test_pipeline.py
@@ -0,0 +1,320 @@
+"""End-to-end inbound pipeline tests (with deduper + async enrichment)."""
+
+import json
+from types import SimpleNamespace
+
+import pytest
+
+from lark_channel.channel.config import InboundConfig, MediaCapabilities, SecurityConfig
+from lark_channel.channel.normalize.dedup import Deduper, InMemoryDedupStore
+from lark_channel.channel.normalize.pipeline import InboundPipeline, PipelineConfig, PipelineDeps
+from lark_channel.channel.types import InteractiveContent, MergeForwardContent, TextContent
+
+
+def _sender(open_id="ou_sender", *, sender_type="user"):
+    return {
+        "sender_id": {"open_id": open_id, "user_id": "u1"},
+        "sender_type": sender_type,
+    }
+
+
+def _msg(
+    *,
+    message_id="om_1",
+    chat_type="p2p",
+    msg_type="text",
+    content=None,
+    parent_id=None,
+    root_id=None,
+    mentions=None,
+):
+    return {
+        "message_id": message_id,
+        "create_time": 1000,
+        "chat_id": "oc_1",
+        "chat_type": chat_type,
+        "message_type": msg_type,
+        "content": json.dumps(content or {"text": "hi"}, ensure_ascii=False),
+        "parent_id": parent_id,
+        "root_id": root_id,
+        "mentions": mentions or [],
+    }
+
+
+@pytest.mark.asyncio
+async def test_text_message_normalized():
+    p = InboundPipeline(PipelineConfig(), PipelineDeps())
+    inbound = await p.process(event_id="e1", message_event=_msg(), sender=_sender())
+    assert inbound is not None
+    assert isinstance(inbound.content, TextContent)
+    assert inbound.content.text == "hi"
+    assert inbound.content_text == "hi"
+    assert inbound.safe_content_text == "hi"
+    assert inbound.sender.open_id == "ou_sender"
+    assert inbound.conversation.chat_type == "p2p"
+
+
+@pytest.mark.asyncio
+async def test_safe_content_text_escapes_flat_text_without_changing_default_content_text():
+    p = InboundPipeline(PipelineConfig(), PipelineDeps())
+    inbound = await p.process(
+        event_id="e_safe_text",
+        message_event=_msg(content={"text": '<at id="all">& hello'}),
+        sender=_sender(),
+    )
+
+    assert inbound is not None
+    assert inbound.content_text == '<at id="all">& hello'
+    assert inbound.safe_content_text == "&lt;at id=&quot;all&quot;&gt;&amp; hello"
+
+
+@pytest.mark.asyncio
+async def test_strict_content_text_uses_safe_content_text():
+    p = InboundPipeline(
+        PipelineConfig(security=SecurityConfig(strict_content_text=True)),
+        PipelineDeps(),
+    )
+    inbound = await p.process(
+        event_id="e_strict_text",
+        message_event=_msg(content={"text": '<at id="all">'}),
+        sender=_sender(),
+    )
+
+    assert inbound is not None
+    assert inbound.content_text == "&lt;at id=&quot;all&quot;&gt;"
+    assert inbound.safe_content_text == "&lt;at id=&quot;all&quot;&gt;"
+
+
+@pytest.mark.asyncio
+async def test_sender_type_app_maps_to_bot_for_dict_sender():
+    p = InboundPipeline(PipelineConfig(), PipelineDeps())
+    inbound = await p.process(
+        event_id="e_app",
+        message_event=_msg(),
+        sender=_sender(open_id="ou_peer_bot", sender_type="app"),
+    )
+    assert inbound is not None
+    assert inbound.sender.open_id == "ou_peer_bot"
+    assert inbound.sender.is_bot is True
+
+
+@pytest.mark.asyncio
+async def test_sender_type_app_maps_to_bot_for_object_sender():
+    p = InboundPipeline(PipelineConfig(), PipelineDeps())
+    sender = SimpleNamespace(
+        sender_id=SimpleNamespace(open_id="ou_peer_bot", user_id="u_peer"),
+        sender_type="app",
+    )
+    inbound = await p.process(event_id="e_app_obj", message_event=_msg(), sender=sender)
+    assert inbound is not None
+    assert inbound.sender.open_id == "ou_peer_bot"
+    assert inbound.sender.is_bot is True
+
+
+@pytest.mark.asyncio
+async def test_pipeline_can_inject_chat_mode_when_enabled():
+    cfg = PipelineConfig(inbound=InboundConfig(inject_chat_mode=True))
+    p = InboundPipeline(cfg, PipelineDeps())
+
+    async def chat_mode(chat_id):
+        assert chat_id == "oc_1"
+        return "thread"
+
+    p.set_chat_mode_resolver(chat_mode)
+
+    inbound = await p.process(
+        event_id="e_chat_mode",
+        message_event=_msg(chat_type="group"),
+        sender=_sender(),
+    )
+
+    assert inbound is not None
+    assert inbound.chat_mode == "thread"
+
+
+@pytest.mark.asyncio
+async def test_pipeline_does_not_inject_chat_mode_by_default():
+    calls = []
+
+    def resolver(chat_id):
+        calls.append(chat_id)
+        return "thread"
+
+    p = InboundPipeline(PipelineConfig(), PipelineDeps())
+    p.set_chat_mode_resolver(resolver)
+
+    inbound = await p.process(
+        event_id="e_no_chat_mode",
+        message_event=_msg(chat_type="group"),
+        sender=_sender(),
+    )
+
+    assert inbound is not None
+    assert inbound.chat_mode is None
+    assert calls == []
+
+
+@pytest.mark.asyncio
+async def test_pipeline_can_exclude_message_raw_when_configured():
+    cfg = PipelineConfig(inbound=InboundConfig(include_raw=False))
+    p = InboundPipeline(cfg, PipelineDeps())
+
+    inbound = await p.process(
+        event_id="e_no_raw",
+        message_event=_msg(message_id="om_no_raw"),
+        sender=_sender(),
+    )
+
+    assert inbound is not None
+    assert inbound.raw == {}
+
+
+@pytest.mark.asyncio
+async def test_pipeline_chat_mode_resolver_failure_keeps_message():
+    cfg = PipelineConfig(inbound=InboundConfig(inject_chat_mode=True))
+    p = InboundPipeline(cfg, PipelineDeps())
+
+    def resolver(chat_id):
+        raise RuntimeError("chat mode lookup failed")
+
+    p.set_chat_mode_resolver(resolver)
+
+    inbound = await p.process(
+        event_id="e_chat_mode_failure",
+        message_event=_msg(chat_type="group"),
+        sender=_sender(),
+    )
+
+    assert inbound is not None
+    assert inbound.content_text == "hi"
+    assert inbound.chat_mode is None
+
+
+@pytest.mark.asyncio
+async def test_dedup_drops_repeat():
+    d = Deduper(InMemoryDedupStore(), ttl_seconds=60)
+    p = InboundPipeline(PipelineConfig(), PipelineDeps(), deduper=d)
+    a = await p.process(event_id="e1", message_event=_msg(), sender=_sender())
+    b = await p.process(event_id="e1", message_event=_msg(), sender=_sender())
+    assert a is not None
+    assert b is None
+
+
+@pytest.mark.asyncio
+async def test_mentions_resolved_and_stripped():
+    msg = _msg(
+        content={"text": "hey @_user_1 ok"},
+        mentions=[{"key": "@_user_1", "id": {"open_id": "ou_A"}, "name": "Alice"}],
+    )
+    p = InboundPipeline(PipelineConfig(), PipelineDeps())
+    inbound = await p.process(event_id="e", message_event=msg, sender=_sender())
+    assert inbound.content.text == "hey @Alice ok"
+    assert inbound.mentions[0].open_id == "ou_A"
+
+
+@pytest.mark.asyncio
+async def test_pipeline_sets_mentioned_bot_without_removing_bot_mention():
+    msg = _msg(
+        chat_type="group",
+        content={"text": "hey @_user_1"},
+        mentions=[
+            {"key": "@_user_1", "id": {"open_id": "ou_bot"}, "name": "Bot"},
+        ],
+    )
+    p = InboundPipeline(PipelineConfig(), PipelineDeps())
+    p.set_bot_open_id("ou_bot")
+
+    inbound = await p.process(event_id="e_bot", message_event=msg, sender=_sender())
+
+    assert inbound is not None
+    assert inbound.mentioned_bot is True
+    assert [m.open_id for m in inbound.mentions] == ["ou_bot"]
+    assert inbound.content.text == "hey @Bot"
+
+
+@pytest.mark.asyncio
+async def test_reply_ref_from_parent_id():
+    msg = _msg(parent_id="om_parent", root_id="om_root")
+    p = InboundPipeline(PipelineConfig(), PipelineDeps())
+    inbound = await p.process(event_id="e", message_event=msg, sender=_sender())
+    assert inbound.reply is not None
+    assert inbound.reply.message_id == "om_parent"
+
+
+@pytest.mark.asyncio
+async def test_media_cap_gate_blocks_image():
+    p = InboundPipeline(
+        PipelineConfig(inbound=InboundConfig(media_capabilities=MediaCapabilities(image=False))),
+        PipelineDeps(),
+    )
+    msg = _msg(msg_type="image", content={"image_key": "img_x"})
+    inbound = await p.process(event_id="e", message_event=msg, sender=_sender())
+    assert inbound is None
+
+
+@pytest.mark.asyncio
+async def test_merge_forward_expanded_via_fetcher():
+    async def fetch_message(mid: str):
+        # Return a children list with one text child
+        return {
+            "data": {
+                "items": [
+                    {
+                        "message_id": mid,
+                        "msg_type": "merge_forward",
+                        "body": {"content": "{}"},
+                    },
+                    {
+                        "message_id": "om_child1",
+                        "msg_type": "text",
+                        "body": {"content": json.dumps({"text": "child text"})},
+                        "sender": {"id": "ou_A"},
+                        "create_time": "2000",
+                    },
+                ]
+            }
+        }
+
+    async def resolve_names(ids):
+        return {i: "Alice" for i in ids}
+
+    p = InboundPipeline(
+        PipelineConfig(),
+        PipelineDeps(fetch_message=fetch_message, resolve_names=resolve_names),
+    )
+    msg = _msg(msg_type="merge_forward", content={})
+    inbound = await p.process(event_id="e", message_event=msg, sender=_sender())
+    assert inbound is not None
+    assert isinstance(inbound.content, MergeForwardContent)
+    assert inbound.content.loading is False
+    assert len(inbound.content.items) == 1
+    child = inbound.content.items[0]
+    assert child.message_id == "om_child1"
+    assert child.sender_name == "Alice"
+    assert isinstance(child.content, TextContent)
+    assert child.content.text == "child text"
+
+
+@pytest.mark.asyncio
+async def test_interactive_is_refetched_and_version_detected():
+    async def fetch_message(mid: str):
+        return {
+            "data": {
+                "items": [
+                    {
+                        "message_id": mid,
+                        "msg_type": "interactive",
+                        "body": {"content": json.dumps({"schema": "2.0", "body": {"elements": []}})},
+                    }
+                ]
+            }
+        }
+
+    p = InboundPipeline(
+        PipelineConfig(),
+        PipelineDeps(fetch_message=fetch_message),
+    )
+    msg = _msg(msg_type="interactive", content={})
+    inbound = await p.process(event_id="e", message_event=msg, sender=_sender())
+    assert isinstance(inbound.content, InteractiveContent)
+    assert inbound.content.card_version == "v2"
diff --git a/lark_channel/channel/tests/test_policy_extended.py b/lark_channel/channel/tests/test_policy_extended.py
new file mode 100644
index 0000000..9012402
--- /dev/null
+++ b/lark_channel/channel/tests/test_policy_extended.py
@@ -0,0 +1,162 @@
+"""Tests for rich policy behavior.
+
+Covers admin bypass, blocklist (DM + group + per-override), admin_only,
+and per-override allowlist precedence.
+"""
+
+from lark_channel.channel import GroupOverride, PolicyConfig
+from lark_channel.channel.safety.policy_gate import PolicyGate
+from lark_channel.channel.types import (
+    Conversation,
+    Identity,
+    InboundMessage,
+    TextContent,
+)
+
+
+BOT = "ou_bot"
+ADMIN = "ou_admin"
+USER = "ou_user"
+EVIL = "ou_evil"
+
+
+def _msg(*, chat_type: str, chat_id: str, sender: str, mentions=None, mentioned_all=False, text="hi"):
+    return InboundMessage(
+        id="m1",
+        create_time=0,
+        conversation=Conversation(chat_id=chat_id, chat_type=chat_type),
+        sender=Identity(open_id=sender),
+        mentions=mentions or [],
+        mentioned_all=mentioned_all,
+        content=TextContent(text=text),
+    )
+
+
+# --- admin bypass ---------------------------------------------------------
+
+def test_admin_bypasses_disabled_group():
+    gate = PolicyGate(PolicyConfig(group_policy="disabled", admins=[ADMIN]))
+    gate.set_bot_open_id(BOT)
+    decision = gate.evaluate(_msg(chat_type="group", chat_id="c1", sender=ADMIN))
+    assert decision.allowed is True
+
+
+def test_admin_bypasses_dm_disabled():
+    gate = PolicyGate(PolicyConfig(dm_policy="disabled", admins=[ADMIN]))
+    decision = gate.evaluate(_msg(chat_type="p2p", chat_id="c1", sender=ADMIN))
+    assert decision.allowed is True
+
+
+def test_non_admin_still_blocked_when_disabled():
+    gate = PolicyGate(PolicyConfig(group_policy="disabled", admins=[ADMIN]))
+    gate.set_bot_open_id(BOT)
+    decision = gate.evaluate(_msg(chat_type="group", chat_id="c1", sender=USER))
+    assert decision.allowed is False
+    assert decision.reason == "policy_group_disabled"
+
+
+# --- DM blocklist ---------------------------------------------------------
+
+def test_dm_blocklist_blocks_listed_sender():
+    gate = PolicyGate(PolicyConfig(dm_policy="blocklist", deny_from=[EVIL]))
+    decision = gate.evaluate(_msg(chat_type="p2p", chat_id="c1", sender=EVIL))
+    assert decision.allowed is False
+    assert decision.reason == "policy_blocklist"
+
+
+def test_dm_blocklist_passes_unlisted_sender():
+    gate = PolicyGate(PolicyConfig(dm_policy="blocklist", deny_from=[EVIL]))
+    decision = gate.evaluate(_msg(chat_type="p2p", chat_id="c1", sender=USER))
+    assert decision.allowed is True
+
+
+# --- Group blocklist ------------------------------------------------------
+
+def test_group_blocklist_blocks_listed_chat():
+    gate = PolicyGate(
+        PolicyConfig(
+            group_policy="blocklist",
+            group_blocklist=["c_blocked"],
+            require_mention=False,
+        )
+    )
+    gate.set_bot_open_id(BOT)
+    decision = gate.evaluate(_msg(chat_type="group", chat_id="c_blocked", sender=USER))
+    assert decision.allowed is False
+    assert decision.reason == "policy_blocklist"
+
+
+def test_group_blocklist_passes_unlisted_chat():
+    gate = PolicyGate(
+        PolicyConfig(
+            group_policy="blocklist",
+            group_blocklist=["c_blocked"],
+            require_mention=False,
+        )
+    )
+    gate.set_bot_open_id(BOT)
+    decision = gate.evaluate(_msg(chat_type="group", chat_id="c_ok", sender=USER))
+    assert decision.allowed is True
+
+
+# --- admin_only ----------------------------------------------------------
+
+def test_admin_only_passes_admin():
+    gate = PolicyGate(
+        PolicyConfig(group_policy="admin_only", admins=[ADMIN], require_mention=False)
+    )
+    gate.set_bot_open_id(BOT)
+    decision = gate.evaluate(_msg(chat_type="group", chat_id="c1", sender=ADMIN))
+    assert decision.allowed is True
+
+
+def test_admin_only_blocks_non_admin():
+    gate = PolicyGate(
+        PolicyConfig(group_policy="admin_only", admins=[ADMIN], require_mention=False)
+    )
+    gate.set_bot_open_id(BOT)
+    decision = gate.evaluate(_msg(chat_type="group", chat_id="c1", sender=USER))
+    assert decision.allowed is False
+    assert decision.reason == "policy_admin_only"
+
+
+def test_admin_only_blocks_when_admins_unset():
+    gate = PolicyGate(PolicyConfig(group_policy="admin_only", require_mention=False))
+    gate.set_bot_open_id(BOT)
+    decision = gate.evaluate(_msg(chat_type="group", chat_id="c1", sender=USER))
+    assert decision.allowed is False
+    assert decision.reason == "policy_admin_only"
+
+
+# --- per-override blocklist + allowlist ----------------------------------
+
+def test_group_override_blocklist_takes_effect():
+    gate = PolicyGate(
+        PolicyConfig(
+            group_policy="open",
+            group_overrides={
+                "c_special": GroupOverride(policy="blocklist", blocklist=[EVIL])
+            },
+            require_mention=False,
+        )
+    )
+    gate.set_bot_open_id(BOT)
+    decision = gate.evaluate(_msg(chat_type="group", chat_id="c_special", sender=EVIL))
+    assert decision.allowed is False
+    assert decision.reason == "policy_blocklist"
+
+
+def test_group_override_allowlist_takes_effect():
+    gate = PolicyGate(
+        PolicyConfig(
+            group_policy="open",
+            group_overrides={
+                "c_special": GroupOverride(policy="allowlist", allowlist=[USER])
+            },
+            require_mention=False,
+        )
+    )
+    gate.set_bot_open_id(BOT)
+    decision = gate.evaluate(_msg(chat_type="group", chat_id="c_special", sender=EVIL))
+    assert decision.allowed is False
+    assert decision.reason == "policy_group_not_in_allowlist"
diff --git a/lark_channel/channel/tests/test_policy_identity_fields.py b/lark_channel/channel/tests/test_policy_identity_fields.py
new file mode 100644
index 0000000..44e3b56
--- /dev/null
+++ b/lark_channel/channel/tests/test_policy_identity_fields.py
@@ -0,0 +1,137 @@
+import pytest
+
+from lark_channel.channel import Conversation, GroupOverride, Identity, InboundMessage
+from lark_channel.channel.config import PolicyConfig
+from lark_channel.channel.safety.policy_gate import PolicyGate
+from lark_channel.channel.types import TextContent
+
+
+def _message(
+    *,
+    chat_type="group",
+    open_id="ou_alice",
+    user_id="u_alice",
+    union_id="on_alice",
+    chat_id="oc_chat",
+):
+    return InboundMessage(
+        id="om_1",
+        create_time=1,
+        conversation=Conversation(chat_id=chat_id, chat_type=chat_type),
+        sender=Identity(open_id=open_id, user_id=user_id, union_id=union_id),
+        content=TextContent(text="hello"),
+    )
+
+
+def test_policy_default_sender_identity_fields_only_match_open_id():
+    gate = PolicyGate(PolicyConfig(allow_from=["u_alice"], require_mention=False))
+
+    decision = gate.evaluate(_message())
+
+    assert decision.allowed is False
+    assert decision.reason == "policy_sender_not_allowed"
+
+
+def test_policy_allow_from_matches_user_id_when_configured():
+    gate = PolicyGate(
+        PolicyConfig(
+            allow_from=["u_alice"],
+            require_mention=False,
+            sender_identity_fields=["open_id", "user_id"],
+        )
+    )
+
+    decision = gate.evaluate(_message())
+
+    assert decision.allowed is True
+
+
+def test_policy_admin_only_matches_admin_user_id_when_configured():
+    gate = PolicyGate(
+        PolicyConfig(
+            group_policy="admin_only",
+            admins=["u_admin"],
+            require_mention=False,
+            sender_identity_fields=["open_id", "user_id"],
+        )
+    )
+
+    decision = gate.evaluate(_message(user_id="u_admin"))
+
+    assert decision.allowed is True
+
+
+def test_policy_group_override_allowlist_matches_user_id_when_configured():
+    gate = PolicyGate(
+        PolicyConfig(
+            group_policy="allowlist",
+            require_mention=False,
+            sender_identity_fields=["open_id", "user_id"],
+            group_overrides={
+                "oc_chat": GroupOverride(allowlist=["u_alice"]),
+            },
+        )
+    )
+
+    decision = gate.evaluate(_message())
+
+    assert decision.allowed is True
+
+
+def test_policy_group_override_blocklist_matches_user_id_when_configured():
+    gate = PolicyGate(
+        PolicyConfig(
+            group_policy="blocklist",
+            require_mention=False,
+            sender_identity_fields=["open_id", "user_id"],
+            group_overrides={
+                "oc_chat": GroupOverride(blocklist=["u_bad"]),
+            },
+        )
+    )
+
+    decision = gate.evaluate(_message(user_id="u_bad"))
+
+    assert decision.allowed is False
+    assert decision.reason == "policy_blocklist"
+
+
+def test_policy_dm_allowlist_matches_user_id_when_configured():
+    gate = PolicyGate(
+        PolicyConfig(
+            dm_policy="allowlist",
+            allow_from=["u_alice"],
+            sender_identity_fields=["open_id", "user_id"],
+        )
+    )
+
+    decision = gate.evaluate(_message(chat_type="p2p"))
+
+    assert decision.allowed is True
+
+
+def test_policy_dm_blocklist_matches_user_id_when_configured():
+    gate = PolicyGate(
+        PolicyConfig(
+            dm_policy="blocklist",
+            deny_from=["u_bad"],
+            sender_identity_fields=["open_id", "user_id"],
+        )
+    )
+
+    decision = gate.evaluate(_message(chat_type="p2p", user_id="u_bad"))
+
+    assert decision.allowed is False
+    assert decision.reason == "policy_blocklist"
+
+
+def test_policy_invalid_sender_identity_field_raises():
+    gate = PolicyGate(
+        PolicyConfig(
+            allow_from=["u_alice"],
+            sender_identity_fields=["email"],
+        )
+    )
+
+    with pytest.raises(ValueError, match="invalid sender identity field: email"):
+        gate.evaluate(_message())
diff --git a/lark_channel/channel/tests/test_public_api_freeze.py b/lark_channel/channel/tests/test_public_api_freeze.py
new file mode 100644
index 0000000..e412c5f
--- /dev/null
+++ b/lark_channel/channel/tests/test_public_api_freeze.py
@@ -0,0 +1,116 @@
+"""Public-API freeze tests for the dedup contract.
+
+Locks the DedupStore Protocol signature and the helper exports so that the
+contract documented to consumers (Hermes JsonFileDedupStore et al.) cannot
+silently drift.
+"""
+
+import ast
+import inspect
+import re
+from pathlib import Path
+
+import pytest
+
+from lark_channel.channel import DedupStore, InMemoryDedupStore
+from lark_channel.channel import make_event_key, make_message_key
+from lark_channel.event.dispatcher_handler import EventDispatcherHandler
+
+
+ROOT = Path(__file__).resolve().parents[3]
+
+
+def test_dedup_store_protocol_methods_frozen():
+    """DedupStore must expose seen(key) and mark(key, ttl_seconds) — no rename."""
+    # seen(key) -> bool
+    sig = inspect.signature(DedupStore.seen)
+    assert list(sig.parameters.keys()) == ["self", "key"]
+
+    # mark(key, ttl_seconds) -> None
+    sig = inspect.signature(DedupStore.mark)
+    assert list(sig.parameters.keys()) == ["self", "key", "ttl_seconds"]
+
+
+def test_in_memory_dedup_store_implements_protocol():
+    """The in-memory reference impl must satisfy the Protocol at runtime."""
+    store = InMemoryDedupStore()
+    assert isinstance(store, DedupStore)
+    assert store.seen("anything") is False
+    store.mark("k1", ttl_seconds=60)
+    assert store.seen("k1") is True
+
+
+def test_make_event_key_format():
+    """Event-keyer must produce stable `evt:<account>:<event_id>` form."""
+    assert make_event_key("acc1", "evt1") == "evt:acc1:evt1"
+
+
+def test_make_message_key_format():
+    """Message-keyer must produce stable `msg:<account>:<message_id>` form."""
+    assert make_message_key("acc1", "msg1") == "msg:acc1:msg1"
+
+
+def test_do_without_validation_public_alias_delegates_with_deprecation(monkeypatch):
+    """Keep the old public method as a deprecated compatibility shim."""
+    handler = EventDispatcherHandler()
+    calls = []
+
+    def fake_dispatch(payload):
+        calls.append(payload)
+        return {"ok": True}
+
+    monkeypatch.setattr(handler, "_do_without_validation", fake_dispatch)
+
+    with pytest.warns(DeprecationWarning, match="do_without_validation"):
+        result = handler.do_without_validation(b'{"schema":"2.0"}')
+
+    assert result == {"ok": True}
+    assert calls == [b'{"schema":"2.0"}']
+
+
+def test_readme_links_channel_docs_and_samples_instead_of_tests():
+    readme = (ROOT / "README.md").read_text(encoding="utf-8")
+
+    assert "lark_channel/channel/tests/" not in readme
+    assert "docs/channel/" not in readme
+    assert "doc/channel/" not in readme
+    assert "docs/quickstart.md" in readme
+    assert "docs/reference.md" in readme
+    assert "samples/channel/echo_bot.py" in readme
+    assert "/blob/v1.6.0/" not in readme
+    assert "/blob/main/docs/" not in readme
+    assert "/blob/main/samples/channel/" not in readme
+    assert "/blob/HEAD/docs/" not in readme
+    assert "/blob/HEAD/samples/channel/" not in readme
+    assert (ROOT / "docs/quickstart.md").is_file()
+    assert (ROOT / "docs/reference.md").is_file()
+    assert (ROOT / "samples/channel/echo_bot.py").is_file()
+
+
+def test_channel_docs_do_not_link_to_unreleased_tag():
+    docs = [ROOT / "README.md", *sorted((ROOT / "docs").glob("*.md"))]
+    for path in docs:
+        text = path.read_text(encoding="utf-8")
+        assert "/blob/v1.6.0/" not in text, str(path)
+
+
+def test_markdown_caption_docs_match_current_media_support():
+    text = (ROOT / "docs/markdown.md").read_text(encoding="utf-8")
+
+    assert "Images and videos can include an optional markdown caption" in text
+    assert "captions are supported for image and video messages only" in text
+    assert "file or audio dictionary inputs is rejected" in text
+    assert "Images and files can include an optional markdown caption" not in text
+    assert "caption` on audio/video dictionary inputs is ignored" not in text
+
+
+def test_channel_docs_python_fences_parse():
+    for path in sorted((ROOT / "docs").glob("*.md")):
+        text = path.read_text(encoding="utf-8")
+        for index, match in enumerate(re.finditer(r"```python\n(.*?)```", text, re.S), 1):
+            ast.parse(match.group(1), filename=f"{path} fence {index}")
+
+
+def test_channel_sample_compiles():
+    sample = ROOT / "samples/channel/echo_bot.py"
+    compile(sample.read_text(encoding="utf-8"), str(sample), "exec")
diff --git a/lark_channel/channel/tests/test_reaction_event.py b/lark_channel/channel/tests/test_reaction_event.py
new file mode 100644
index 0000000..562f373
--- /dev/null
+++ b/lark_channel/channel/tests/test_reaction_event.py
@@ -0,0 +1,169 @@
+"""Regression: reaction event field path + 'own' / 'all' filter.
+
+The real `P2ImMessageReactionCreatedV1Data` exposes `user_id: UserId`, not
+`operator_id`. Drives the event through `_handle_reaction_event` with a
+real model instantiated from a realistic JSON payload.
+"""
+
+import time
+from types import SimpleNamespace
+from unittest.mock import AsyncMock
+
+import pytest
+
+from lark_channel.channel import FeishuChannel as _ChannelClient
+from lark_channel.channel.types import SendResult
+from lark_channel.api.im.v1.model.p2_im_message_reaction_created_v1 import (
+    P2ImMessageReactionCreatedV1,
+)
+
+
+_PAYLOAD = {
+    "schema": "2.0",
+    "header": {
+        "event_id": "e1",
+        "token": "tk",
+        "app_id": "cli_dummy",
+        "tenant_key": "tk",
+        "event_type": "im.message.reaction.created_v1",
+        "create_time": str(int(time.time() * 1000)),
+    },
+    "event": {
+        "message_id": "om_target",
+        "reaction_type": {"emoji_type": "THUMBSUP"},
+        "operator_type": "user",
+        "user_id": {"union_id": "on_U", "user_id": "u", "open_id": "ou_reactor"},
+        "action_time": str(int(time.time() * 1000)),
+        "app_id": "cli_dummy",
+    },
+}
+
+
+@pytest.mark.asyncio
+async def test_reaction_event_reads_open_id_correctly():
+    client = _ChannelClient(app_id="cli_dummy", app_secret="s")
+    client._track_sent_message("om_target")
+
+    captured = []
+    client.on("reaction", lambda event: captured.append(event))
+
+    data = P2ImMessageReactionCreatedV1(_PAYLOAD)
+    await client._handle_reaction_event(data, action="create")
+
+    assert len(captured) == 1
+    e = captured[0]
+    assert e.message_id == "om_target"
+    assert e.operator.open_id == "ou_reactor"
+    assert e.emoji_type == "THUMBSUP"
+    assert e.action == "added"
+
+
+@pytest.mark.asyncio
+async def test_reaction_event_uses_sent_chat_context_when_raw_event_omits_chat():
+    client = _ChannelClient(app_id="cli_dummy", app_secret="s")
+    client._sender.send = AsyncMock(return_value=SendResult.ok(message_id="om_target"))
+
+    result = await client.send("oc_1", {"text": "hello"}, {"receive_id_type": "chat_id"})
+    assert result.success is True
+
+    captured = []
+    client.on("reaction", lambda event: captured.append(event))
+
+    data = P2ImMessageReactionCreatedV1(_PAYLOAD)
+    await client._handle_reaction_event(data, action="create")
+
+    assert len(captured) == 1
+    assert captured[0].chat_id == "oc_1"
+    assert captured[0].chat_type is None
+
+
+@pytest.mark.asyncio
+async def test_reaction_event_does_not_guess_chat_context_for_non_chat_targets():
+    client = _ChannelClient(app_id="cli_dummy", app_secret="s")
+    client._sender.send = AsyncMock(return_value=SendResult.ok(message_id="om_target"))
+
+    result = await client.send("ou_1", {"text": "hello"}, {"receive_id_type": "open_id"})
+    assert result.success is True
+
+    captured = []
+    client.on("reaction", lambda event: captured.append(event))
+
+    data = P2ImMessageReactionCreatedV1(_PAYLOAD)
+    await client._handle_reaction_event(data, action="create")
+
+    assert len(captured) == 1
+    assert captured[0].chat_id is None
+    assert captured[0].chat_type is None
+
+
+@pytest.mark.asyncio
+async def test_reaction_event_prefers_raw_chat_context_over_sent_context():
+    client = _ChannelClient(app_id="cli_dummy", app_secret="s")
+    client._sender.send = AsyncMock(return_value=SendResult.ok(message_id="om_target"))
+    await client.send("oc_sent", {"text": "hello"}, {"receive_id_type": "chat_id"})
+
+    captured = []
+    client.on("reaction", lambda event: captured.append(event))
+
+    data = SimpleNamespace(
+        event=SimpleNamespace(
+            message_id="om_target",
+            user_id=SimpleNamespace(open_id="ou_reactor"),
+            reaction_type=SimpleNamespace(emoji_type="THUMBSUP"),
+            action_time=str(int(time.time() * 1000)),
+            chat_id="oc_raw",
+            chat_type="group",
+        )
+    )
+    await client._handle_reaction_event(data, action="create")
+
+    assert len(captured) == 1
+    assert captured[0].chat_id == "oc_raw"
+    assert captured[0].chat_type == "group"
+
+
+@pytest.mark.asyncio
+async def test_reaction_event_tracks_chunk_ids_for_sent_chat_context():
+    client = _ChannelClient(app_id="cli_dummy", app_secret="s")
+    client._sender.send = AsyncMock(
+        return_value=SendResult.ok(message_id="om_first", chunk_ids=["om_first", "om_second"])
+    )
+    await client.send("oc_1", {"text": "hello"}, {"receive_id_type": "chat_id"})
+
+    captured = []
+    client.on("reaction", lambda event: captured.append(event))
+
+    payload = dict(_PAYLOAD)
+    payload["event"] = dict(_PAYLOAD["event"], message_id="om_second")
+    data = P2ImMessageReactionCreatedV1(payload)
+    await client._handle_reaction_event(data, action="create")
+
+    assert len(captured) == 1
+    assert captured[0].message_id == "om_second"
+    assert captured[0].chat_id == "oc_1"
+
+
+@pytest.mark.asyncio
+async def test_reaction_own_filter_drops_untracked():
+    client = _ChannelClient(app_id="cli_dummy", app_secret="s")
+    # No _track_sent_message → reaction on unknown message dropped in 'own' mode.
+
+    captured = []
+    client.on("reaction", lambda event: captured.append(event))
+
+    data = P2ImMessageReactionCreatedV1(_PAYLOAD)
+    await client._handle_reaction_event(data, action="create")
+    assert captured == []
+
+
+@pytest.mark.asyncio
+async def test_reaction_all_mode_forwards_everything():
+    client = _ChannelClient(app_id="cli_dummy", app_secret="s")
+    client._config.inbound.reaction_notifications = "all"
+
+    captured = []
+    client.on("reaction", lambda event: captured.append(event))
+
+    data = P2ImMessageReactionCreatedV1(_PAYLOAD)
+    await client._handle_reaction_event(data, action="create")
+    assert len(captured) == 1
diff --git a/lark_channel/channel/tests/test_reject_reasons.py b/lark_channel/channel/tests/test_reject_reasons.py
new file mode 100644
index 0000000..2e834f0
--- /dev/null
+++ b/lark_channel/channel/tests/test_reject_reasons.py
@@ -0,0 +1,78 @@
+"""Reject-reason vocabulary lock-in.
+
+Pins the policy_* prefixed names so downstream
+consumers (Hermes metrics) can match on a stable taxonomy.
+"""
+
+from typing import get_args
+
+from lark_channel.channel import RejectReason
+
+
+EXPECTED_REASONS = {
+    # Non-policy
+    "stale",
+    "duplicate",
+    "lock_contention",
+    "self_sent",
+    # Policy
+    "policy_dm_disabled",
+    "policy_group_disabled",
+    "policy_dm_not_in_allowlist",
+    "policy_group_not_in_allowlist",
+    "policy_blocklist",
+    "policy_admin_only",
+    "policy_no_mention",
+    "policy_mention_all_blocked",
+    "policy_sender_not_allowed",
+}
+
+
+def test_reject_reason_literal_exact_set():
+    """RejectReason Literal must contain exactly the agreed-upon vocabulary."""
+    actual = set(get_args(RejectReason))
+    assert actual == EXPECTED_REASONS, (
+        f"missing: {EXPECTED_REASONS - actual}, extra: {actual - EXPECTED_REASONS}"
+    )
+
+
+def test_legacy_reasons_removed():
+    """Legacy unprefixed names must not appear — the rename is a clean cut."""
+    legacy = {
+        "group_not_allowed",
+        "sender_not_allowed",
+        "no_mention",
+        "dm_disabled",
+        "mention_all_blocked",
+    }
+    actual = set(get_args(RejectReason))
+    overlap = actual & legacy
+    assert not overlap, f"legacy reasons still present: {overlap}"
+
+
+# --- PolicyConfig / GroupOverride schema ----------------------------------
+
+from lark_channel.channel import DmPolicy, GroupOverride, GroupPolicy, PolicyConfig
+
+
+def test_group_policy_literal_includes_blocklist_and_admin_only():
+    actual = set(get_args(GroupPolicy))
+    assert actual == {"open", "allowlist", "blocklist", "admin_only", "disabled"}
+
+
+def test_dm_policy_literal_includes_blocklist():
+    actual = set(get_args(DmPolicy))
+    assert actual == {"open", "allowlist", "blocklist", "disabled"}
+
+
+def test_policy_config_has_new_fields_with_defaults():
+    cfg = PolicyConfig()
+    assert cfg.deny_from is None
+    assert cfg.group_blocklist is None
+    assert cfg.admins is None
+
+
+def test_group_override_has_allowlist_and_blocklist():
+    ov = GroupOverride()
+    assert ov.allowlist is None
+    assert ov.blocklist is None
diff --git a/lark_channel/channel/tests/test_reliability.py b/lark_channel/channel/tests/test_reliability.py
new file mode 100644
index 0000000..e24760e
--- /dev/null
+++ b/lark_channel/channel/tests/test_reliability.py
@@ -0,0 +1,224 @@
+"""Reliability tests for the four fixes batched in the 2.0 reliability pass:
+
+- ``ProcessingLock`` periodic sweep (prevents unbounded dict growth)
+- ``ProcessingLock`` monotonic clock (immune to NTP step-back)
+- ``ChatPipeline`` closure-chain release (prevents GC retention of completed
+  ancestors)
+- ``FeishuChannel`` bot-identity retry loop (recovers from startup network
+  hiccups instead of permanently disabling group @Bot detection)
+"""
+
+import asyncio
+import gc
+import weakref
+from unittest.mock import patch
+
+import pytest
+
+from lark_channel.channel import FeishuChannel
+from lark_channel.channel.bot_identity import BotIdentity
+from lark_channel.channel.safety import ChatPipeline, ProcessingLock
+from lark_channel.channel.safety.types import TextBatchConfig
+
+
+# ---------------------------------------------------------------------------
+# ProcessingLock — periodic sweep + monotonic clock
+# ---------------------------------------------------------------------------
+
+
+def test_processing_lock_periodic_sweep_trims_expired_entries():
+    """Under heavy churn, acquire() must drop expired entries so the
+    internal dict doesn't grow unboundedly."""
+    lock = ProcessingLock(ttl_ms=10, sweep_interval_ms=0)  # always-sweep
+
+    # Fill 100 unique keys — all expire immediately (ttl=10ms).
+    for i in range(100):
+        assert lock.acquire(f"k{i}") is True
+
+    # Wait out the TTL so every entry is expired.
+    import time
+    time.sleep(0.05)
+
+    # A single acquire of a fresh key should trigger the sweep and drop
+    # everything else. Size() itself sweeps too; we want acquire() to have
+    # already done the work.
+    lock.acquire("fresh")
+    # After the sweep + the one fresh insert, size should be 1 (not 101).
+    assert lock.size() == 1
+
+
+def test_processing_lock_monotonic_clock_survives_wall_clock_regression():
+    """If the wall clock were used, a simulated backward jump would make an
+    active lock look expired. Monotonic clock must keep locks valid."""
+    lock = ProcessingLock(ttl_ms=60_000)
+    assert lock.acquire("x") is True
+
+    # Patch time.time (wall clock) to 30 years ago. The lock uses
+    # time.monotonic internally so this must have NO effect.
+    with patch("time.time", return_value=0.0):
+        assert lock.acquire("x") is False  # still held
+    lock.release("x")
+
+
+# ---------------------------------------------------------------------------
+# ChatPipeline — closure chain must not retain completed ancestors
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_chat_pipeline_releases_ancestor_tasks_after_await():
+    """Long serialization chains must let completed ancestors GC before the
+    whole chain drains. We enqueue 10 tasks, grab a weakref to the first
+    task, let all run to completion, then force GC and assert the ref is
+    dead."""
+    loop = asyncio.get_running_loop()
+    pipe = ChatPipeline(
+        "scope",
+        TextBatchConfig(delay_ms=10, max_messages=1, max_chars=10),
+        loop,
+        serial_only=True,
+    )
+
+    async def noop():
+        return None
+
+    tasks = [pipe._enqueue(noop) for _ in range(10)]
+    first_ref = weakref.ref(tasks[0])
+    # Wait for every task to finish.
+    await asyncio.gather(*tasks)
+    # Drop our own refs so only the pipeline's closure chain (if any) keeps
+    # the first task alive.
+    first_task_id = id(tasks[0])
+    del tasks
+    for _ in range(3):
+        gc.collect()
+        await asyncio.sleep(0)
+
+    assert first_ref() is None, (
+        "ChatPipeline runner closures retained a completed ancestor task — "
+        "long chat histories will leak memory. "
+        f"first_task_id={first_task_id}"
+    )
+
+
+# ---------------------------------------------------------------------------
+# FeishuChannel — bot identity retry loop
+# ---------------------------------------------------------------------------
+
+
+def _channel() -> FeishuChannel:
+    return FeishuChannel(app_id="cli_x", app_secret="s")
+
+
+@pytest.mark.asyncio
+async def test_bot_identity_retry_loop_succeeds_after_transient_failure():
+    """Simulate ``fetch_bot_identity`` returning None once then succeeding.
+    The retry loop must pick up the success and publish the identity."""
+    ch = _channel()
+    ch._ensure_bg_loop()
+    # Shrink the backoff table so the test doesn't wait 10s for the first
+    # retry.
+    ch._BOT_IDENTITY_RETRY_DELAYS_S = (0.05, 0.05, 0.05)
+
+    identity = BotIdentity(open_id="ou_bot_x", app_id="cli_x", name="TestBot")
+    call_count = {"n": 0}
+
+    async def flaky_fetch(_cfg):
+        call_count["n"] += 1
+        if call_count["n"] == 1:
+            return None
+        return identity
+
+    with patch(
+        "lark_channel.channel.channel.fetch_bot_identity", side_effect=flaky_fetch
+    ):
+        # Drive the retry loop directly (sync path would trigger the real
+        # 10s timeout).
+        await asyncio.wait_for(
+            asyncio.wrap_future(
+                asyncio.run_coroutine_threadsafe(
+                    ch._bot_identity_retry_loop(), ch._bg_loop
+                )
+            ),
+            timeout=2.0,
+        )
+
+    assert ch.bot_identity is not None
+    assert ch.bot_identity.open_id == "ou_bot_x"
+    assert ch._bot_open_id == "ou_bot_x"
+    ch.stop()
+
+
+@pytest.mark.asyncio
+async def test_bot_identity_retry_loop_respects_shutdown():
+    """Shutdown fires mid-retry → loop bails out cleanly without touching
+    state."""
+    ch = _channel()
+    ch._ensure_bg_loop()
+    ch._BOT_IDENTITY_RETRY_DELAYS_S = (0.2, 0.2)
+
+    async def never_succeeds(_cfg):
+        return None
+
+    with patch(
+        "lark_channel.channel.channel.fetch_bot_identity", side_effect=never_succeeds
+    ):
+        # Kick the loop off, then shut down almost immediately.
+        fut = asyncio.run_coroutine_threadsafe(
+            ch._bot_identity_retry_loop(), ch._bg_loop
+        )
+        await asyncio.sleep(0.05)
+        ch._shutdown.set()
+        # Loop should notice shutdown and return cleanly (not raise, not
+        # hang).
+        await asyncio.wait_for(asyncio.wrap_future(fut), timeout=2.0)
+
+    assert ch.bot_identity is None
+    ch.stop()
+
+
+def test_bot_identity_store_is_atomic_under_concurrent_writes():
+    """Two threads writing the identity simultaneously must never leave
+    the pair of fields in a half-updated state (fresh ``_bot_identity`` +
+    stale ``_bot_open_id`` or vice-versa)."""
+    import threading
+
+    ch = _channel()
+    id_a = BotIdentity(open_id="ou_a", app_id="cli_x", name="A")
+    id_b = BotIdentity(open_id="ou_b", app_id="cli_x", name="B")
+
+    observed_mismatches = []
+    stop = threading.Event()
+
+    def writer(identity):
+        while not stop.is_set():
+            ch._store_bot_identity(identity)
+
+    def reader():
+        while not stop.is_set():
+            with ch._bot_identity_lock:
+                ident = ch._bot_identity
+                open_id = ch._bot_open_id
+            if ident is None:
+                continue
+            if ident.open_id != open_id:
+                observed_mismatches.append((ident.open_id, open_id))
+
+    threads = [
+        threading.Thread(target=writer, args=(id_a,), daemon=True),
+        threading.Thread(target=writer, args=(id_b,), daemon=True),
+        threading.Thread(target=reader, daemon=True),
+    ]
+    for t in threads:
+        t.start()
+    import time
+    time.sleep(0.3)
+    stop.set()
+    for t in threads:
+        t.join(timeout=1.0)
+
+    assert not observed_mismatches, (
+        f"observed {len(observed_mismatches)} inconsistent reads of "
+        f"(_bot_identity, _bot_open_id) under concurrent writes — "
+        f"first few: {observed_mismatches[:3]}"
+    )
diff --git a/lark_channel/channel/tests/test_reliability_regressions.py b/lark_channel/channel/tests/test_reliability_regressions.py
new file mode 100644
index 0000000..97e2669
--- /dev/null
+++ b/lark_channel/channel/tests/test_reliability_regressions.py
@@ -0,0 +1,254 @@
+"""Reliability regression tests for connection and reconnect behavior."""
+
+from __future__ import annotations
+
+import asyncio
+import threading
+from unittest.mock import patch
+
+import pytest
+
+from lark_channel.channel import FeishuChannel
+from lark_channel.channel.errors import FeishuChannelError, FeishuChannelErrorCode
+from lark_channel.ws.exception import ClientException
+
+
+def _channel() -> FeishuChannel:
+    return FeishuChannel(app_id="cli_test", app_secret="sec")
+
+
+def test_stop_cancels_bot_identity_retry_loop():
+    ch = _channel()
+    ch._ensure_bg_loop()
+    ch._start_bot_identity_retry_loop()
+
+    retry_future = ch._bot_identity_retry_future
+    assert retry_future is not None
+
+    ch.stop()
+
+    assert retry_future.cancelled() or retry_future.done()
+
+
+@pytest.mark.asyncio
+async def test_failed_ws_start_cleans_up_bot_identity_retry_loop():
+    ch = _channel()
+
+    class _FailingWS:
+        def __init__(self, *a, **kw):
+            self._conn = None
+
+        def start(self) -> None:
+            raise ClientException(1000040346, "app_id is invalid")
+
+    async def _no_identity(_cfg):
+        return None
+
+    with patch("lark_channel.channel.channel.WSClient", _FailingWS), patch(
+        "lark_channel.channel.channel.fetch_bot_identity", side_effect=_no_identity
+    ):
+        with pytest.raises(FeishuChannelError):
+            await asyncio.wait_for(ch.connect(), timeout=10)
+
+    retry_future = ch._bot_identity_retry_future
+    assert retry_future is not None
+    assert retry_future.cancelled() or retry_future.done()
+    assert ch._bg_loop is None
+
+
+# ---------------------------------------------------------------------------
+# Invalid credentials must surface as NOT_CONNECTED.
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_invalid_credentials_error_has_not_connected_code():
+    """When the WS handshake fails because app_id/app_secret are invalid,
+    the channel must raise ``FeishuChannelError`` with code
+    ``NOT_CONNECTED`` instead of the raw ``ClientException`` from
+    :mod:`lark_channel.ws.client`, whose ``.code`` is an ``int`` upstream error
+    code, not a :class:`FeishuChannelErrorCode`.
+    """
+    ch = _channel()
+
+    class _FailingWS:
+        def __init__(self, *a, **kw):
+            self._conn = None
+
+        def start(self) -> None:
+            raise ClientException(1000040346, "app_id is invalid")
+
+    raised: Exception | None = None
+    with patch("lark_channel.channel.channel.WSClient", _FailingWS), patch.object(
+        FeishuChannel, "_fetch_bot_identity_sync", lambda self: None
+    ):
+        try:
+            await asyncio.wait_for(ch.connect(), timeout=10)
+        except Exception as e:
+            raised = e
+        finally:
+            try:
+                ch.stop()
+            except Exception:
+                pass
+
+    assert raised is not None, "connect() with invalid credentials must raise"
+
+    # Public contract: error.code is a FeishuChannelErrorCode whose .value
+    # equals "not_connected".
+    assert isinstance(raised, FeishuChannelError), (
+        f"expected FeishuChannelError, got {type(raised).__name__}: {raised!r}"
+    )
+    assert raised.code is FeishuChannelErrorCode.NOT_CONNECTED, (
+        f"expected NOT_CONNECTED, got {raised.code!r}"
+    )
+    assert raised.code.value == "not_connected"
+
+
+# ---------------------------------------------------------------------------
+# Reconnect after graceful disconnect must rebuild ws_client.
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_reconnect_after_disconnect_reinitializes_ws_client():
+    """Lifecycle contract:
+
+    1. ``await channel.connect()`` brings the channel up.
+    2. ``await channel.disconnect()`` tears it down cleanly.
+    3. A subsequent ``await channel.connect()`` must bring it back up —
+       ``channel.ws_client`` should be a fresh non-None WSClient.
+
+    The second connect must rebuild the client instead of short-circuiting on
+    stale lifecycle flags.
+    """
+    ch = _channel()
+
+    fake_ws_instances: list = []
+
+    class _FakeWS:
+        def __init__(self, *a, **kw):
+            self._conn = object()
+            self._stopped = False
+            fake_ws_instances.append(self)
+
+        def start(self) -> None:
+            # Non-blocking start: the real WSClient.start() blocks on
+            # run_until_complete(_select); we just want to observe that it
+            # was created.
+            return None
+
+        def stop(self) -> None:
+            self._stopped = True
+
+    # Patch both the imported symbol in channel.py and keep fetch_bot_identity
+    # fast so the sync start() doesn't stall.
+    async def _no_identity(_cfg):
+        return None
+
+    with patch("lark_channel.channel.channel.WSClient", _FakeWS), patch(
+        "lark_channel.channel.channel.fetch_bot_identity", side_effect=_no_identity
+    ):
+        await ch.connect()
+        assert ch.ws_client is not None, "first connect() must build a WSClient"
+        first = ch.ws_client
+
+        await ch.disconnect()
+        # disconnect() is documented to tear down — ws_client may be None
+        # here, that's expected.
+
+        # The bug: this second connect() must rebuild the ws_client.
+        await ch.connect()
+
+    assert ch.ws_client is not None, (
+        "connect() after disconnect() must rebuild ws_client"
+    )
+    assert ch.ws_client is not first, (
+        "reconnect must produce a fresh WSClient instance, not reuse the "
+        "torn-down one"
+    )
+
+    # Tidy up regardless of pass/fail.
+    try:
+        ch.stop()
+    except Exception:
+        pass
+
+
+# ---------------------------------------------------------------------------
+# reconnecting / reconnected events must be dispatched.
+# ---------------------------------------------------------------------------
+
+
+def test_reconnecting_event_is_dispatched_on_ws_reconnect():
+    """When the underlying WS transport reconnects, ``channel`` must fire
+    ``reconnecting`` and ``reconnected`` events to user handlers.
+
+    ``FeishuChannel`` defines ``_notify_reconnecting`` /
+    ``_notify_reconnected`` and :data:`ChannelEventName` advertises both
+    event names. Drive a reconnect through a fake transport and assert the
+    channel-level handlers fire.
+    """
+    ch = _channel()
+    reconnecting_seen = threading.Event()
+    reconnected_seen = threading.Event()
+
+    ch.on("reconnecting", lambda *_a, **_kw: reconnecting_seen.set())
+    ch.on("reconnected", lambda *_a, **_kw: reconnected_seen.set())
+
+    # Mimic the real transport lifecycle: build a WSClient that exposes the
+    # ``on_reconnecting`` / ``on_reconnected`` observer hooks (fixed on the
+    # real :class:`lark_channel.ws.client.Client`). FeishuChannel is expected to
+    # wire its internal notifiers onto these attributes at start() time.
+    class _FakeWS:
+        def __init__(self, *a, **kw):
+            self._conn = object()
+            # Default no-op — FeishuChannel.start() overrides these.
+            self.on_reconnecting = lambda: None
+            self.on_reconnected = lambda: None
+
+        def start(self) -> None:
+            return None
+
+        def stop(self) -> None:
+            return None
+
+        async def _reconnect(self) -> None:
+            # A faithful stand-in for lark_channel.ws.client.Client._reconnect:
+            # fire ``on_reconnecting`` before retrying, then fire
+            # ``on_reconnected`` once a connect succeeds. The real client in
+            # ws/client.py does exactly this after the 2.0 fix.
+            self.on_reconnecting()
+            self.on_reconnected()
+
+    async def _no_identity(_cfg):
+        return None
+
+    with patch("lark_channel.channel.channel.WSClient", _FakeWS), patch(
+        "lark_channel.channel.channel.fetch_bot_identity", side_effect=_no_identity
+    ):
+        ch.start()
+        ws = ch.ws_client
+        assert ws is not None
+
+        # Drive a reconnect through the underlying transport.
+        loop = asyncio.new_event_loop()
+        try:
+            loop.run_until_complete(ws._reconnect())
+        finally:
+            loop.close()
+
+    try:
+        assert reconnecting_seen.wait(1.0), (
+            "after the underlying ws client reconnects, channel must fire "
+            "'reconnecting'"
+        )
+        assert reconnected_seen.wait(1.0), (
+            "after the underlying ws client reconnects, channel must fire "
+            "'reconnected'"
+        )
+    finally:
+        try:
+            ch.stop()
+        except Exception:
+            pass
diff --git a/lark_channel/channel/tests/test_reply_target_gone_behavior.py b/lark_channel/channel/tests/test_reply_target_gone_behavior.py
new file mode 100644
index 0000000..c7a2039
--- /dev/null
+++ b/lark_channel/channel/tests/test_reply_target_gone_behavior.py
@@ -0,0 +1,123 @@
+import pytest
+
+from lark_channel.channel import OutboundSender, OutboundText
+from lark_channel.channel._coerce import coerce_send_opts
+from lark_channel.channel.config import OutboundConfig, RetryConfig
+from lark_channel.channel.errors import FeishuChannelErrorCode
+
+
+class RecordingDriver:
+    def __init__(self, reply_raw=None):
+        self.reply_raw = reply_raw or {"code": 0, "data": {"message_id": "om_reply"}}
+        self.create_calls = []
+        self.reply_calls = []
+
+    async def reply_message(self, **kwargs):
+        self.reply_calls.append(kwargs)
+        return self.reply_raw
+
+    async def create_message(self, **kwargs):
+        self.create_calls.append(kwargs)
+        return {"code": 0, "data": {"message_id": "om_create"}}
+
+
+def _sender(driver):
+    return OutboundSender(
+        driver,
+        config=OutboundConfig(retry=RetryConfig(max_attempts=1, base_delay_ms=0)),
+    )
+
+
+def test_coerce_send_opts_defaults_reply_target_gone_to_fresh():
+    opts = coerce_send_opts(None)
+
+    assert opts.reply_target_gone == "fresh"
+
+
+def test_coerce_send_opts_accepts_snake_case_reply_target_gone():
+    opts = coerce_send_opts({"reply_target_gone": "fail"})
+
+    assert opts.reply_target_gone == "fail"
+
+
+def test_coerce_send_opts_accepts_camel_case_reply_target_gone():
+    opts = coerce_send_opts({"replyTargetGone": "fail"})
+
+    assert opts.reply_target_gone == "fail"
+
+
+def test_coerce_send_opts_rejects_invalid_reply_target_gone():
+    with pytest.raises(ValueError, match="invalid reply_target_gone: ignore"):
+        coerce_send_opts({"reply_target_gone": "ignore"})
+
+
+@pytest.mark.asyncio
+async def test_reply_target_gone_defaults_to_fresh_create():
+    driver = RecordingDriver(reply_raw={"code": 230002, "msg": "target gone"})
+
+    result = await _sender(driver).send(
+        OutboundText(text="hello"),
+        receive_id="oc_chat",
+        receive_id_type="chat_id",
+        reply_to="om_parent",
+    )
+
+    assert result.success is True
+    assert result.message_id == "om_create"
+    assert len(driver.reply_calls) == 1
+    assert len(driver.create_calls) == 1
+
+
+@pytest.mark.asyncio
+async def test_reply_target_gone_fail_returns_reply_failure_without_create():
+    driver = RecordingDriver(reply_raw={"code": 230002, "msg": "target gone"})
+
+    result = await _sender(driver).send(
+        OutboundText(text="hello"),
+        receive_id="oc_chat",
+        receive_id_type="chat_id",
+        reply_to="om_parent",
+        reply_target_gone="fail",
+    )
+
+    assert result.success is False
+    assert result.error.code == FeishuChannelErrorCode.TARGET_REVOKED
+    assert len(driver.reply_calls) == 1
+    assert len(driver.create_calls) == 0
+
+
+@pytest.mark.asyncio
+async def test_reply_in_thread_still_passes_to_reply_request():
+    driver = RecordingDriver()
+
+    result = await _sender(driver).send(
+        OutboundText(text="hello"),
+        receive_id="oc_chat",
+        receive_id_type="chat_id",
+        reply_to="om_parent",
+        reply_in_thread=True,
+        reply_target_gone="fail",
+    )
+
+    assert result.success is True
+    assert driver.reply_calls[0]["reply_in_thread"] is True
+
+
+@pytest.mark.asyncio
+async def test_multi_chunk_reply_target_gone_fail_stops_after_first_chunk():
+    driver = RecordingDriver(reply_raw={"code": 230002, "msg": "target gone"})
+    sender = _sender(driver)
+    sender._config.text_chunk_limit = 5
+
+    result = await sender.send(
+        OutboundText(text="first\nsecond\nthird"),
+        receive_id="oc_chat",
+        receive_id_type="chat_id",
+        reply_to="om_parent",
+        reply_target_gone="fail",
+    )
+
+    assert result.success is False
+    assert result.error.code == FeishuChannelErrorCode.TARGET_REVOKED
+    assert len(driver.reply_calls) == 1
+    assert len(driver.create_calls) == 0
diff --git a/lark_channel/channel/tests/test_retry_and_fallback.py b/lark_channel/channel/tests/test_retry_and_fallback.py
new file mode 100644
index 0000000..1dc463a
--- /dev/null
+++ b/lark_channel/channel/tests/test_retry_and_fallback.py
@@ -0,0 +1,135 @@
+"""Retry / fallback tests for OutboundSender."""
+
+import json
+from typing import List
+
+import pytest
+
+from lark_channel.channel.config import OutboundConfig
+from lark_channel.channel.errors import FeishuChannelErrorCode, SendError
+from lark_channel.channel.outbound.retry import with_retry
+from lark_channel.channel.outbound.sender import OutboundSender, SendDriver
+from lark_channel.channel.types import OutboundPost, OutboundText, SendResult
+
+
+# ---- retry primitive ------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_retry_success_on_second_attempt():
+    attempts = []
+
+    async def op(i):
+        attempts.append(i)
+        if i == 0:
+            return SendResult.fail(SendError(code=FeishuChannelErrorCode.RATE_LIMITED, retryable=True))
+        return SendResult.ok(message_id="om_ok")
+
+    r = await with_retry(op, max_attempts=3, base_delay_ms=1, jitter=False)
+    assert r.success and r.message_id == "om_ok"
+    assert attempts == [0, 1]
+
+
+@pytest.mark.asyncio
+async def test_retry_stops_on_non_retryable():
+    attempts = []
+
+    async def op(i):
+        attempts.append(i)
+        return SendResult.fail(SendError(code=FeishuChannelErrorCode.FORMAT_ERROR, retryable=False))
+
+    r = await with_retry(op, max_attempts=3, base_delay_ms=1, jitter=False)
+    assert r.success is False
+    assert attempts == [0]
+
+
+@pytest.mark.asyncio
+async def test_retry_exhausts_attempts():
+    attempts = []
+
+    async def op(i):
+        attempts.append(i)
+        return SendResult.fail(SendError(code=FeishuChannelErrorCode.RATE_LIMITED, retryable=True))
+
+    r = await with_retry(op, max_attempts=3, base_delay_ms=1, jitter=False)
+    assert r.success is False
+    assert attempts == [0, 1, 2]
+
+
+# ---- sender-level fallback ------------------------------------------------
+
+
+def _driver(responses: List[dict]):
+    idx = 0
+    calls: List[dict] = []
+
+    async def create_message(**kwargs):
+        nonlocal idx
+        calls.append({"op": "create", **kwargs})
+        r = responses[idx] if idx < len(responses) else {"code": 0, "data": {"message_id": "om_ok"}}
+        idx += 1
+        return r
+
+    async def reply_message(**kwargs):
+        nonlocal idx
+        calls.append({"op": "reply", **kwargs})
+        r = responses[idx] if idx < len(responses) else {"code": 0, "data": {"message_id": "om_reply"}}
+        idx += 1
+        return r
+
+    return SendDriver(create_message=create_message, reply_message=reply_message), calls
+
+
+@pytest.mark.asyncio
+async def test_format_error_post_downgrades_to_text():
+    """POST rejected with 230099 → retry as plain text (post_to_plain_text extraction)."""
+    d, calls = _driver([
+        {"code": 230099, "msg": "invalid card"},  # initial post — retryable? no, but fallback triggers
+    ])
+    s = OutboundSender(d)
+    s._retry_max_attempts = 1
+    r = await s.send(OutboundPost(markdown="**hi**"), receive_id="oc_1")
+    assert r.success is True
+    # The fallback call should have msg_type=text
+    text_calls = [c for c in calls if c.get("msg_type") == "text"]
+    assert len(text_calls) == 1
+    assert json.loads(text_calls[0]["content"])["text"]
+
+
+@pytest.mark.asyncio
+async def test_reply_target_gone_retries_as_fresh():
+    d, calls = _driver([
+        {"code": 230020, "msg": "target revoked"},  # reply hits revoked target
+    ])
+    s = OutboundSender(d)
+    s._retry_max_attempts = 1
+    r = await s.send(OutboundText(text="hi"), reply_to="om_dead", receive_id="oc_1")
+    assert r.success is True
+    ops = [c["op"] for c in calls]
+    assert ops[0] == "reply"
+    assert ops[1] == "create"  # fell back to fresh create
+
+
+@pytest.mark.asyncio
+async def test_transient_error_retries_once():
+    d, calls = _driver([
+        {"code": 11020, "msg": "rate limited"},
+    ])
+    s = OutboundSender(d)
+    s._retry_max_attempts = 2
+    s._retry_base_delay_ms = 1
+    r = await s.send(OutboundText(text="hi"), receive_id="oc_1")
+    assert r.success is True
+    assert len(calls) == 2
+
+
+@pytest.mark.asyncio
+async def test_long_text_splits_preserving_order_first_reply_only():
+    d, calls = _driver([])
+    s = OutboundSender(d, OutboundConfig(text_chunk_limit=10, chunk_mode="none"))
+    s._retry_max_attempts = 1
+    r = await s.send(OutboundText(text="a" * 25), reply_to="om_target", receive_id="oc_1")
+    assert r.success is True
+    assert calls[0]["op"] == "reply"   # first chunk replies
+    for c in calls[1:]:
+        assert c["op"] == "create"     # subsequent chunks are fresh
diff --git a/lark_channel/channel/tests/test_router.py b/lark_channel/channel/tests/test_router.py
new file mode 100644
index 0000000..774ff58
--- /dev/null
+++ b/lark_channel/channel/tests/test_router.py
@@ -0,0 +1,27 @@
+"""Tests for receive_id_type inference."""
+
+from lark_channel.channel.outbound.routing import infer_receive_id_type
+
+
+def test_open_id():
+    assert infer_receive_id_type("ou_abc") == "open_id"
+
+
+def test_chat_id():
+    assert infer_receive_id_type("oc_xyz") == "chat_id"
+
+
+def test_union_id():
+    assert infer_receive_id_type("on_foo") == "union_id"
+
+
+def test_email():
+    assert infer_receive_id_type("a@b.com") == "email"
+
+
+def test_user_id_default():
+    assert infer_receive_id_type("123456") == "user_id"
+
+
+def test_empty_is_chat_id():
+    assert infer_receive_id_type("") == "chat_id"
diff --git a/lark_channel/channel/tests/test_safety.py b/lark_channel/channel/tests/test_safety.py
new file mode 100644
index 0000000..b1eaf55
--- /dev/null
+++ b/lark_channel/channel/tests/test_safety.py
@@ -0,0 +1,412 @@
+"""Unit tests for the new safety/ module."""
+
+import asyncio
+import time
+from typing import List
+
+import pytest
+
+from lark_channel.channel.config import PolicyConfig, GroupOverride
+from lark_channel.channel.safety import (
+    ChatPipeline,
+    PolicyGate,
+    ProcessingLock,
+    RejectEvent,
+    SafetyPipeline,
+    SeenCache,
+    TextBatchConfig,
+    is_stale,
+    merge_batch,
+)
+from lark_channel.channel.types import (
+    Conversation,
+    Identity,
+    InboundMessage,
+    Mention,
+    TextContent,
+)
+
+
+# ---- stale_detector --------------------------------------------------------
+
+
+def test_is_stale_recent_false():
+    now_ms = int(time.time() * 1000)
+    assert is_stale(now_ms - 1000) is False
+
+
+def test_is_stale_old_true():
+    now_ms = int(time.time() * 1000)
+    assert is_stale(now_ms - 35 * 60_000) is True
+
+
+def test_is_stale_zero_returns_false():
+    assert is_stale(0) is False
+
+
+# ---- seen_cache ------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_seen_cache_basic():
+    s = SeenCache()
+    assert await s.has("a") is False
+    await s.add("a")
+    assert await s.has("a") is True
+
+
+def test_seen_cache_lru_bounded():
+    s = SeenCache(max_entries=3)
+    for k in "abcd":
+        s.add_sync(k)
+    assert s.has_sync("a") is False  # evicted
+    assert s.has_sync("d") is True
+
+
+def test_seen_cache_falls_back_to_external():
+    """If memory misses but external cache hits, it should back-fill."""
+
+    class FakeCache:
+        def __init__(self):
+            self.store = {"channel:seen:x": "1"}
+
+        def get(self, key):
+            return self.store.get(key)
+
+        def set(self, key, value, expire=None):
+            self.store[key] = value
+
+    fake = FakeCache()
+    s = SeenCache(cache=fake)
+    assert s.has_sync("x") is True  # not in memory but in fake cache
+    assert s.has_sync("x") is True  # now back-filled to memory
+
+
+# ---- processing_lock -------------------------------------------------------
+
+
+def test_processing_lock_acquire_and_release():
+    lock = ProcessingLock()
+    assert lock.acquire("id1") is True
+    assert lock.acquire("id1") is False  # still held
+    lock.release("id1")
+    assert lock.acquire("id1") is True
+
+
+def test_processing_lock_ttl_expires():
+    lock = ProcessingLock(ttl_ms=50)
+    assert lock.acquire("id1") is True
+    time.sleep(0.08)
+    assert lock.acquire("id1") is True  # expired → fresh lock
+
+
+# ---- policy_gate -----------------------------------------------------------
+
+
+def _msg(**kw) -> InboundMessage:
+    return InboundMessage(
+        id=kw.get("id", "om1"),
+        create_time=int(time.time() * 1000),
+        conversation=Conversation(
+            chat_id=kw.get("chat_id", "oc_1"),
+            chat_type=kw.get("chat_type", "p2p"),
+        ),
+        sender=Identity(open_id=kw.get("sender", "ou_sender")),
+        mentions=kw.get("mentions", []),
+        mentioned_all=kw.get("mentioned_all", False),
+        mentioned_bot=kw.get("mentioned_bot", False),
+        chat_mode=kw.get("chat_mode"),
+        content=TextContent(text=kw.get("text", "hi")),
+    )
+
+
+def test_policy_gate_dm_open_allows():
+    gate = PolicyGate(PolicyConfig(dm_policy="open"))
+    assert gate.evaluate(_msg()).allowed is True
+
+
+def test_policy_gate_dm_disabled_reasons():
+    gate = PolicyGate(PolicyConfig(dm_policy="disabled"))
+    d = gate.evaluate(_msg())
+    assert d.allowed is False
+    assert d.reason == "policy_dm_disabled"
+
+
+def test_policy_gate_group_no_mention():
+    gate = PolicyGate(PolicyConfig(require_mention=True))
+    gate.set_bot_open_id("ou_bot")
+    d = gate.evaluate(_msg(chat_type="group"))
+    assert d.allowed is False
+    assert d.reason == "policy_no_mention"
+
+
+def test_policy_gate_group_mention_bot():
+    gate = PolicyGate(PolicyConfig(require_mention=True))
+    gate.set_bot_open_id("ou_bot")
+    d = gate.evaluate(_msg(chat_type="group", mentions=[Mention(key="@_bot", open_id="ou_bot")]))
+    assert d.allowed is True
+
+
+def test_policy_gate_group_mention_all_blocked():
+    gate = PolicyGate(PolicyConfig(require_mention=True, respond_to_mention_all=False))
+    gate.set_bot_open_id("ou_bot")
+    d = gate.evaluate(_msg(chat_type="group", mentioned_all=True))
+    assert d.allowed is False
+    # "policy_no_mention" hits first because the @-all isn't the bot
+    assert d.reason == "policy_no_mention"
+
+
+def test_policy_gate_update_policy_runtime():
+    gate = PolicyGate(PolicyConfig(dm_policy="open"))
+    assert gate.evaluate(_msg()).allowed is True
+    gate.update_policy(dm_policy="disabled")
+    assert gate.evaluate(_msg()).allowed is False
+
+
+def test_policy_gate_group_allowlist():
+    gate = PolicyGate(PolicyConfig(group_policy="allowlist", group_allowlist=["oc_ok"], require_mention=False))
+    assert gate.evaluate(_msg(chat_type="group", chat_id="oc_ok")).allowed is True
+    d = gate.evaluate(_msg(chat_type="group", chat_id="oc_other"))
+    assert d.allowed is False
+    assert d.reason == "policy_group_not_in_allowlist"
+
+
+def test_policy_gate_group_override_disables():
+    gate = PolicyGate(PolicyConfig(
+        group_overrides={"oc_X": GroupOverride(enabled=False)},
+    ))
+    d = gate.evaluate(_msg(chat_type="group", chat_id="oc_X"))
+    assert d.allowed is False
+
+
+# ---- merge_batch -----------------------------------------------------------
+
+
+def test_merge_batch_single_returns_unchanged():
+    m = _msg(text="one")
+    merged = merge_batch([m])
+    assert merged is m
+
+
+def test_merge_batch_multiple_joins_text():
+    a = _msg(id="a", text="帮我")
+    b = _msg(id="b", text="写一个")
+    c = _msg(id="c", text="快排")
+    merged = merge_batch([a, b, c])
+    assert merged.id == "c"  # last wins
+    assert "帮我" in merged.content.text
+    assert "写一个" in merged.content.text
+    assert "快排" in merged.content.text
+
+
+def test_merge_batch_preserves_mentioned_bot_flag():
+    a = _msg(id="a", text="hi", mentioned_bot=True)
+    b = _msg(id="b", text="there")
+
+    merged = merge_batch([a, b])
+
+    assert merged.mentioned_bot is True
+
+
+def test_merge_batch_preserves_chat_mode():
+    a = _msg(id="a", text="hi", chat_mode="thread")
+    b = _msg(id="b", text="there", chat_mode="thread")
+
+    merged = merge_batch([a, b])
+
+    assert merged.chat_mode == "thread"
+
+
+def test_merge_batch_uses_last_chat_mode_when_present():
+    a = _msg(id="a", text="hi", chat_mode="thread")
+    b = _msg(id="b", text="there", chat_mode="group")
+
+    merged = merge_batch([a, b])
+
+    assert merged.chat_mode == "group"
+
+
+def test_merge_batch_falls_back_to_first_chat_mode_when_last_missing():
+    a = _msg(id="a", text="hi", chat_mode="thread")
+    b = _msg(id="b", text="there")
+
+    merged = merge_batch([a, b])
+
+    assert merged.chat_mode == "thread"
+
+
+# ---- chat_pipeline ---------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_chat_pipeline_debounces_and_merges():
+    loop = asyncio.get_running_loop()
+    pipeline = ChatPipeline(
+        "oc_x",
+        TextBatchConfig(delay_ms=50, max_messages=10, max_chars=10_000),
+        loop,
+    )
+    merged_captured: List[InboundMessage] = []
+
+    async def handler(merged, sources):
+        merged_captured.append(merged)
+
+    pipeline.push(_msg(id="1", text="hello"), handler)
+    pipeline.push(_msg(id="2", text="world"), handler)
+    # Wait for debounce
+    await asyncio.sleep(0.1)
+    await pipeline.dispose()
+    assert len(merged_captured) == 1
+    assert "hello" in merged_captured[0].content.text
+    assert "world" in merged_captured[0].content.text
+
+
+@pytest.mark.asyncio
+async def test_chat_pipeline_flush_on_max_messages():
+    loop = asyncio.get_running_loop()
+    pipeline = ChatPipeline(
+        "oc_x",
+        TextBatchConfig(delay_ms=5000, max_messages=2, max_chars=10_000),
+        loop,
+    )
+    merged_captured: List[InboundMessage] = []
+
+    async def handler(merged, sources):
+        merged_captured.append(merged)
+
+    pipeline.push(_msg(id="1", text="a"), handler)
+    pipeline.push(_msg(id="2", text="b"), handler)  # triggers max_messages flush
+    await asyncio.sleep(0.02)
+    await pipeline.dispose()
+    assert len(merged_captured) == 1
+
+
+@pytest.mark.asyncio
+async def test_chat_pipeline_run_chains_serially():
+    loop = asyncio.get_running_loop()
+    pipeline = ChatPipeline("x", TextBatchConfig(), loop, serial_only=True)
+    log: List[str] = []
+
+    async def make_task(name: str, delay: float):
+        async def task():
+            log.append(f"{name}:start")
+            await asyncio.sleep(delay)
+            log.append(f"{name}:end")
+        return task
+
+    t1 = await make_task("A", 0.05)
+    t2 = await make_task("B", 0.01)
+    r1 = pipeline.run(t1)
+    r2 = pipeline.run(t2)
+    await asyncio.gather(r1, r2)
+    assert log == ["A:start", "A:end", "B:start", "B:end"]
+
+
+# ---- SafetyPipeline integration --------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_safety_pipeline_drops_stale():
+    loop = asyncio.get_running_loop()
+    got: List[InboundMessage] = []
+
+    async def on_msg(m):
+        got.append(m)
+
+    sp = SafetyPipeline(loop=loop, on_message=on_msg, policy=PolicyConfig(dm_policy="open"))
+    old = _msg()
+    old.create_time = int((time.time() - 3600) * 1000)  # 1h old
+    await sp.push_message(old)
+    await asyncio.sleep(0.05)
+    assert got == []
+
+
+@pytest.mark.asyncio
+async def test_safety_pipeline_dedup():
+    loop = asyncio.get_running_loop()
+    got = []
+
+    async def on_msg(m):
+        got.append(m)
+
+    sp = SafetyPipeline(loop=loop, on_message=on_msg, policy=PolicyConfig(dm_policy="open"),
+                        batch_config=TextBatchConfig(delay_ms=0))
+    m1 = _msg(id="o1")
+    await sp.push_message(m1)
+    await asyncio.sleep(0.05)
+    await sp.push_message(m1)  # duplicate
+    await asyncio.sleep(0.05)
+    assert len(got) == 1
+
+
+@pytest.mark.asyncio
+async def test_safety_pipeline_emits_reject():
+    loop = asyncio.get_running_loop()
+    rejected: List[RejectEvent] = []
+
+    async def on_msg(m):
+        pass
+
+    sp = SafetyPipeline(
+        loop=loop,
+        on_message=on_msg,
+        on_reject=lambda e: rejected.append(e),
+        policy=PolicyConfig(dm_policy="disabled"),
+    )
+    await sp.push_message(_msg())
+    await asyncio.sleep(0.02)
+    assert len(rejected) == 1
+    assert rejected[0].reason == "policy_dm_disabled"
+
+
+@pytest.mark.asyncio
+async def test_safety_pipeline_batches_rapid_messages():
+    loop = asyncio.get_running_loop()
+    got: List[InboundMessage] = []
+
+    async def on_msg(m):
+        got.append(m)
+
+    sp = SafetyPipeline(
+        loop=loop,
+        on_message=on_msg,
+        policy=PolicyConfig(dm_policy="open"),
+        batch_config=TextBatchConfig(delay_ms=50, max_messages=10, max_chars=10_000),
+    )
+    await sp.push_message(_msg(id="1", text="帮我"))
+    await sp.push_message(_msg(id="2", text="写一个"))
+    await sp.push_message(_msg(id="3", text="快排"))
+    await asyncio.sleep(0.15)
+    assert len(got) == 1
+    assert "帮我" in got[0].content.text
+    assert "快排" in got[0].content.text
+
+
+@pytest.mark.asyncio
+async def test_safety_pipeline_processing_lock_blocks_concurrent():
+    loop = asyncio.get_running_loop()
+    call_count = 0
+    enter_event = asyncio.Event()
+    proceed = asyncio.Event()
+
+    async def on_msg(m):
+        nonlocal call_count
+        call_count += 1
+        enter_event.set()
+        await proceed.wait()
+
+    sp = SafetyPipeline(
+        loop=loop,
+        on_message=on_msg,
+        policy=PolicyConfig(dm_policy="open"),
+        batch_config=TextBatchConfig(delay_ms=0),
+    )
+    # First push — handler runs and awaits `proceed`
+    await sp.push_message(_msg(id="o1"))
+    await enter_event.wait()
+    # Second push of same id while handler is still running — lock blocks
+    await sp.push_message(_msg(id="o1"))
+    await asyncio.sleep(0.05)
+    proceed.set()
+    await asyncio.sleep(0.05)
+    assert call_count == 1
diff --git a/lark_channel/channel/tests/test_safety_pipeline_tiers.py b/lark_channel/channel/tests/test_safety_pipeline_tiers.py
new file mode 100644
index 0000000..1f9e69c
--- /dev/null
+++ b/lark_channel/channel/tests/test_safety_pipeline_tiers.py
@@ -0,0 +1,203 @@
+"""Cover the 3 tiers of SafetyPipeline (push_message / push_action / push_light)."""
+
+import asyncio
+from typing import List
+
+import pytest
+
+from lark_channel.channel.config import PolicyConfig
+from lark_channel.channel.safety import RejectEvent, SafetyPipeline
+from lark_channel.channel.safety.types import TextBatchConfig
+
+
+# ---- push_action (tier 2) ----------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_push_action_runs_handler_once():
+    loop = asyncio.get_running_loop()
+    sp = SafetyPipeline(loop=loop, on_message=lambda m: None)
+    calls: List[int] = []
+
+    async def handler():
+        calls.append(1)
+
+    await sp.push_action(event_id="ev_1", queue_scope="oc_1", handler=handler)
+    await asyncio.sleep(0.05)
+    assert calls == [1]
+
+
+@pytest.mark.asyncio
+async def test_push_action_dedupes_duplicate_event():
+    loop = asyncio.get_running_loop()
+    sp = SafetyPipeline(loop=loop, on_message=lambda m: None)
+    calls: List[int] = []
+
+    async def handler():
+        calls.append(1)
+
+    await sp.push_action(event_id="ev_same", queue_scope="oc_1", handler=handler)
+    await asyncio.sleep(0.05)
+    await sp.push_action(event_id="ev_same", queue_scope="oc_1", handler=handler)
+    await asyncio.sleep(0.05)
+    assert calls == [1]  # second was dropped
+
+
+@pytest.mark.asyncio
+async def test_push_action_serial_queue_preserves_order():
+    loop = asyncio.get_running_loop()
+    sp = SafetyPipeline(loop=loop, on_message=lambda m: None)
+    order: List[str] = []
+
+    async def slow():
+        order.append("slow-start")
+        await asyncio.sleep(0.05)
+        order.append("slow-end")
+
+    async def fast():
+        order.append("fast-start")
+        order.append("fast-end")
+
+    await sp.push_action("ev_A", "oc_scope", slow)
+    await sp.push_action("ev_B", "oc_scope", fast)
+    await asyncio.sleep(0.2)
+    assert order == ["slow-start", "slow-end", "fast-start", "fast-end"]
+
+
+@pytest.mark.asyncio
+async def test_push_action_handler_exception_is_logged_not_raised():
+    loop = asyncio.get_running_loop()
+    sp = SafetyPipeline(loop=loop, on_message=lambda m: None)
+
+    async def bad():
+        raise RuntimeError("oops")
+
+    # Should not raise at push time
+    await sp.push_action("ev_x", "oc_x", bad)
+    await asyncio.sleep(0.05)
+
+
+# ---- push_light (tier 3) ------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_push_light_runs_handler():
+    loop = asyncio.get_running_loop()
+    sp = SafetyPipeline(loop=loop, on_message=lambda m: None)
+    calls: List[int] = []
+
+    async def h():
+        calls.append(1)
+
+    await sp.push_light("ev_l", h)
+    assert calls == [1]
+
+
+@pytest.mark.asyncio
+async def test_push_light_dedupes():
+    loop = asyncio.get_running_loop()
+    sp = SafetyPipeline(loop=loop, on_message=lambda m: None)
+    calls: List[int] = []
+
+    async def h():
+        calls.append(1)
+
+    await sp.push_light("ev_same", h)
+    await sp.push_light("ev_same", h)
+    assert calls == [1]
+
+
+@pytest.mark.asyncio
+async def test_push_light_sync_handler_accepted():
+    loop = asyncio.get_running_loop()
+    sp = SafetyPipeline(loop=loop, on_message=lambda m: None)
+    calls: List[int] = []
+
+    def h():
+        calls.append(1)
+
+    await sp.push_light("ev_sync", h)
+    assert calls == [1]
+
+
+@pytest.mark.asyncio
+async def test_push_light_handler_exception_swallowed():
+    loop = asyncio.get_running_loop()
+    sp = SafetyPipeline(loop=loop, on_message=lambda m: None)
+
+    async def bad():
+        raise ValueError("x")
+
+    await sp.push_light("ev_bad", bad)  # no raise
+
+
+# ---- queue disabled / direct dispatch path -----------------------------
+
+
+@pytest.mark.asyncio
+async def test_message_pipeline_direct_dispatch_when_queue_disabled():
+    from lark_channel.channel.safety.types import ChatQueueConfig
+
+    loop = asyncio.get_running_loop()
+    got = []
+
+    async def on_msg(m):
+        got.append(m)
+
+    sp = SafetyPipeline(
+        loop=loop,
+        on_message=on_msg,
+        policy=PolicyConfig(dm_policy="open"),
+        queue_config=ChatQueueConfig(enabled=False),
+        batch_config=TextBatchConfig(delay_ms=0),
+    )
+    from lark_channel.channel.types import Conversation, Identity, InboundMessage, TextContent
+    import time
+    msg = InboundMessage(
+        id="om_direct", create_time=int(time.time() * 1000),
+        conversation=Conversation(chat_id="oc_1", chat_type="p2p"),
+        sender=Identity(open_id="ou_s"),
+        content=TextContent(text="x"),
+    )
+    await sp.push_message(msg)
+    assert len(got) == 1
+
+
+# ---- dispose drains --------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_dispose_clears_pipelines():
+    loop = asyncio.get_running_loop()
+    sp = SafetyPipeline(loop=loop, on_message=lambda m: None)
+    await sp.push_action("e", "scope", lambda: None)
+    await asyncio.sleep(0.05)
+    await sp.dispose()
+
+
+# ---- on_reject handler can be awaitable ---------------------------------
+
+
+@pytest.mark.asyncio
+async def test_push_message_reject_fires_on_reject_handler():
+    from lark_channel.channel.types import Conversation, Identity, InboundMessage, TextContent
+    import time
+
+    loop = asyncio.get_running_loop()
+    rejected: List[RejectEvent] = []
+
+    sp = SafetyPipeline(
+        loop=loop,
+        on_message=lambda m: None,
+        on_reject=lambda e: rejected.append(e),
+        policy=PolicyConfig(dm_policy="disabled"),
+    )
+    msg = InboundMessage(
+        id="om_r", create_time=int(time.time() * 1000),
+        conversation=Conversation(chat_id="oc_1", chat_type="p2p"),
+        sender=Identity(open_id="ou_s"),
+        content=TextContent(text="x"),
+    )
+    await sp.push_message(msg)
+    await asyncio.sleep(0.02)
+    assert len(rejected) == 1 and rejected[0].reason == "policy_dm_disabled"
diff --git a/lark_channel/channel/tests/test_safety_types.py b/lark_channel/channel/tests/test_safety_types.py
new file mode 100644
index 0000000..7f3397c
--- /dev/null
+++ b/lark_channel/channel/tests/test_safety_types.py
@@ -0,0 +1,66 @@
+"""Coverage for safety/types.py default values."""
+
+from lark_channel.channel.safety.types import (
+    BatchConfig,
+    ChatQueueConfig,
+    DedupConfig,
+    MediaBatchConfig,
+    RejectEvent,
+    TextBatchConfig,
+)
+
+
+def test_text_batch_defaults_match_node_spec():
+    t = TextBatchConfig()
+    assert t.delay_ms == 600
+    assert t.long_threshold_chars == 1000
+    assert t.long_delay_ms == 2000
+    assert t.max_messages == 8
+    assert t.max_chars == 4000
+
+
+def test_batch_config_composes_text_and_media():
+    b = BatchConfig()
+    assert isinstance(b.text, TextBatchConfig)
+    assert isinstance(b.media, MediaBatchConfig)
+
+
+# --- MediaBatchConfig schema ----------------------------------------------
+
+from lark_channel.channel import MediaBatchConfig as PublicMediaBatchConfig
+from lark_channel.channel import SafetyConfig
+
+
+def test_media_batch_default_disabled():
+    """Default must keep enabled=False so existing setups don't change behavior."""
+    m = PublicMediaBatchConfig()
+    assert m.enabled is False
+    assert m.delay_ms == 800
+    assert m.max_items == 9
+    assert m.compatible_kinds == frozenset({"image", "file", "audio", "video"})
+
+
+def test_safety_config_media_batch_default_present():
+    cfg = SafetyConfig()
+    assert isinstance(cfg.media_batch, PublicMediaBatchConfig)
+    assert cfg.media_batch.enabled is False
+
+
+def test_chat_queue_enabled_by_default():
+    assert ChatQueueConfig().enabled is True
+
+
+def test_dedup_config_defaults_match_12h_12h():
+    d = DedupConfig()
+    assert d.ttl_seconds == 12 * 3600
+    assert d.max_entries == 5000
+    assert d.sweep_seconds == 5 * 60
+
+
+def test_reject_event_is_a_simple_dataclass():
+    e = RejectEvent(
+        message_id="om_1", chat_id="oc_1", sender_id="ou_1",
+        reason="policy_dm_disabled",
+    )
+    assert e.reason == "policy_dm_disabled"
+    assert e.message_id == "om_1"
diff --git a/lark_channel/channel/tests/test_security_config.py b/lark_channel/channel/tests/test_security_config.py
new file mode 100644
index 0000000..758a98b
--- /dev/null
+++ b/lark_channel/channel/tests/test_security_config.py
@@ -0,0 +1,205 @@
+"""Security configuration compatibility contract."""
+
+import inspect
+from dataclasses import replace
+
+import lark_channel
+import lark_channel.channel as channel_api
+import pytest
+from lark_channel.channel import ChannelConfig
+from lark_channel.channel.config import TransportConfig
+
+
+def test_security_config_defaults_to_compat_mode():
+    SecurityConfig = getattr(lark_channel, "SecurityConfig")
+    config = SecurityConfig()
+
+    assert config.mode == "compat"
+    assert config.is_compat is True
+    assert config.is_audit is False
+    assert config.is_strict is False
+    assert config.enforce_strict_error_response is False
+    assert config.strict_content_text is False
+    assert config.audit_recorder is not None
+
+
+def test_security_config_accepts_audit_and_strict_modes():
+    SecurityConfig = getattr(lark_channel, "SecurityConfig")
+
+    assert SecurityConfig(mode="audit").is_audit is True
+    assert SecurityConfig(mode="strict").is_strict is True
+    assert SecurityConfig(mode="strict").enforce_strict_error_response is True
+
+
+def test_security_config_derived_flags_follow_replaced_mode():
+    SecurityConfig = getattr(lark_channel, "SecurityConfig")
+
+    config = replace(SecurityConfig(mode="compat"), mode="strict")
+
+    assert config.mode == "strict"
+    assert config.enforce_strict_error_response is True
+
+
+def test_security_config_accepts_audit_recorder_override():
+    SecurityConfig = getattr(lark_channel, "SecurityConfig")
+    from lark_channel.event.security import InMemorySecurityAuditRecorder
+
+    recorder = InMemorySecurityAuditRecorder()
+    config = SecurityConfig(audit_recorder=recorder)
+
+    assert config.audit_recorder is recorder
+
+
+def test_security_config_rejects_invalid_audit_recorder():
+    SecurityConfig = getattr(lark_channel, "SecurityConfig")
+
+    with pytest.raises(TypeError, match="audit_recorder"):
+        SecurityConfig(audit_recorder=object())
+
+
+@pytest.mark.parametrize(
+    "field_name",
+    [
+        "max_ws_fragment_parts",
+        "max_ws_fragment_bytes",
+        "max_concurrent_ws_handlers",
+    ],
+)
+@pytest.mark.parametrize("value", [0, -1])
+def test_security_config_resource_limits_must_be_positive(field_name, value):
+    SecurityConfig = getattr(lark_channel, "SecurityConfig")
+
+    with pytest.raises(ValueError, match=field_name):
+        SecurityConfig(**{field_name: value})
+
+
+@pytest.mark.parametrize(
+    "field_name",
+    [
+        "max_ws_fragment_parts",
+        "max_ws_fragment_bytes",
+        "max_concurrent_ws_handlers",
+    ],
+)
+@pytest.mark.parametrize("value", [1.5, "1", True])
+def test_security_config_resource_limits_must_be_integer(field_name, value):
+    SecurityConfig = getattr(lark_channel, "SecurityConfig")
+
+    with pytest.raises(TypeError, match=field_name):
+        SecurityConfig(**{field_name: value})
+
+
+@pytest.mark.parametrize(
+    "field_name",
+    [
+        "allow_unsigned_encrypted_webhook",
+        "allow_insecure_ws",
+        "allow_local_insecure_ws",
+        "strict_error_response",
+        "strict_content_text",
+        "legacy_token_cache_fallback",
+    ],
+)
+def test_security_config_bool_fields_reject_non_bool_values(field_name):
+    SecurityConfig = getattr(lark_channel, "SecurityConfig")
+
+    with pytest.raises(TypeError, match=field_name):
+        SecurityConfig(**{field_name: "false"})
+
+
+def test_security_config_rejects_unsupported_resource_overflow_policy():
+    SecurityConfig = getattr(lark_channel, "SecurityConfig")
+
+    with pytest.raises(ValueError, match="resource_overflow_policy"):
+        SecurityConfig(resource_overflow_policy="reject")
+
+
+def test_security_mode_type_is_public():
+    SecurityMode = getattr(channel_api, "SecurityMode")
+    mode: SecurityMode = "compat"
+
+    assert mode == "compat"
+
+
+def test_channel_config_security_is_optional_and_defaults_to_compat():
+    SecurityConfig = getattr(lark_channel, "SecurityConfig")
+    config = ChannelConfig()
+
+    assert isinstance(config.security, SecurityConfig)
+    assert config.security.mode == "compat"
+
+
+def test_channel_config_keeps_existing_positional_arguments_stable():
+    signature = inspect.signature(ChannelConfig)
+    params = list(signature.parameters)
+
+    assert params[-1] == "security"
+    assert params.index("security") > params.index("media_cache")
+
+    config = ChannelConfig(
+        "cli_xxx",
+        "secret",
+        "https://example.invalid",
+    )
+    assert config.app_id == "cli_xxx"
+    assert config.app_secret == "secret"
+    assert config.domain == "https://example.invalid"
+    assert isinstance(config.transport, TransportConfig)
+    assert config.security.mode == "compat"
+
+
+def test_channel_config_field_order_is_stable_for_positional_callers():
+    signature = inspect.signature(ChannelConfig)
+
+    assert list(signature.parameters) == [
+        "app_id",
+        "app_secret",
+        "domain",
+        "log_level",
+        "encrypt_key",
+        "verification_token",
+        "transport",
+        "chat_mode_cache",
+        "policy",
+        "safety",
+        "inbound",
+        "outbound",
+        "uat",
+        "http_executor",
+        "media_cache",
+        "security",
+    ]
+
+
+def test_feishu_channel_defaults_to_compat_security():
+    channel = lark_channel.FeishuChannel(app_id="cli_xxx", app_secret="secret")
+
+    assert channel.config.security.mode == "compat"
+
+
+def test_feishu_channel_accepts_security_override():
+    SecurityConfig = getattr(lark_channel, "SecurityConfig")
+    security = SecurityConfig(mode="strict")
+
+    channel = lark_channel.FeishuChannel(
+        app_id="cli_xxx",
+        app_secret="secret",
+        security=security,
+    )
+
+    assert channel.config.security.mode == "strict"
+    assert getattr(channel.client.config, "security") is security
+
+
+def test_feishu_channel_preserves_security_from_config():
+    SecurityConfig = getattr(lark_channel, "SecurityConfig")
+
+    channel = lark_channel.FeishuChannel(
+        config=ChannelConfig(
+            app_id="cli_xxx",
+            app_secret="secret",
+            security=SecurityConfig(mode="audit"),
+        )
+    )
+
+    assert channel.config.security.mode == "audit"
diff --git a/lark_channel/channel/tests/test_seen_cache_and_ssrf_paths.py b/lark_channel/channel/tests/test_seen_cache_and_ssrf_paths.py
new file mode 100644
index 0000000..4f9d5bb
--- /dev/null
+++ b/lark_channel/channel/tests/test_seen_cache_and_ssrf_paths.py
@@ -0,0 +1,189 @@
+"""Direct coverage for SeenCache expiry, SSRF resolution, and media reads."""
+
+import asyncio
+import socket
+import time
+from types import SimpleNamespace
+from unittest.mock import patch
+
+import pytest
+
+from lark_channel.channel import FeishuChannel as _ChannelClient
+from lark_channel.channel.errors import FeishuChannelErrorCode, FeishuChannelError
+from lark_channel.channel.safety import SeenCache
+from lark_channel.channel.outbound.media.ssrf_guard import assert_public_url
+
+
+# ---- SeenCache: real TTL expiry, not just ttl=0 -----------------------------
+
+
+@pytest.mark.asyncio
+async def test_seen_cache_expires_after_real_ttl():
+    cache = SeenCache(ttl_seconds=1, sweep_seconds=0)
+    await cache.add("k1")
+    assert await cache.has("k1") is True
+    # Hard-advance the internal expire time by poking the memory map directly.
+    # (We don't want this test to literally sleep >1s.)
+    expired_at = time.time() - 1
+    cache._memory["k1"] = expired_at
+    assert await cache.has("k1") is False
+
+
+# ---- SSRF via IPv6 resolution path -----------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_ssrf_blocks_ipv6_loopback_resolve():
+    """A hostname resolving to `::1` must be blocked."""
+    with patch(
+        "socket.getaddrinfo",
+        return_value=[(socket.AF_INET6, 0, 0, "", ("::1", 0, 0, 0))],
+    ):
+        with pytest.raises(FeishuChannelError) as ei:
+            await assert_public_url("https://v6-internal.test")
+        assert ei.value.code == FeishuChannelErrorCode.SSRF_BLOCKED
+        assert "::1" in str(ei.value)
+
+
+@pytest.mark.asyncio
+async def test_ssrf_allows_public_ipv6():
+    with patch(
+        "socket.getaddrinfo",
+        return_value=[(socket.AF_INET6, 0, 0, "", ("2606:4700:4700::1111", 0, 0, 0))],
+    ):
+        # Should not raise
+        await assert_public_url("https://ipv6-public.example")
+
+
+# ---- Full _handle_message_event pipeline drive ------------------------------
+
+
+@pytest.mark.asyncio
+async def test_handle_message_event_end_to_end_dispatches_to_user():
+    """Feed a realistic im.message.receive_v1-shaped object all the way
+    through pipeline + safety + dispatch → user handler."""
+    c = _ChannelClient(app_id="cli_x", app_secret="sec")
+    c._ensure_bg_loop()
+    # Simulate bot identity so policy-gate's mention logic is correct
+    c._bot_open_id = "ou_bot"
+    c._safety.set_bot_open_id("ou_bot")
+
+    got = []
+
+    async def on_message(event):
+        got.append(event)
+
+    c.on("message", on_message)
+
+    # Craft a minimal event payload (attribute-only, like the real P2 object)
+    import json as _json
+    now_ms = int(time.time() * 1000)
+    payload = SimpleNamespace(
+        header=SimpleNamespace(event_id=f"e_{now_ms}"),
+        event=SimpleNamespace(
+            sender=SimpleNamespace(
+                sender_id=SimpleNamespace(open_id="ou_u1", user_id="u1"),
+                sender_type="user",
+            ),
+            message=SimpleNamespace(
+                message_id=f"om_{now_ms}",
+                root_id="",
+                parent_id="",
+                create_time=str(now_ms),
+                update_time=str(now_ms),
+                chat_id="oc_p2p",
+                thread_id=None,
+                chat_type="p2p",
+                message_type="text",
+                content=_json.dumps({"text": "hello world"}),
+                mentions=[],
+                user_agent=None,
+            ),
+        ),
+    )
+
+    # Must run the driver on the background loop so the SafetyPipeline's
+    # ChatPipeline timers get scheduled on the right loop.
+    fut = asyncio.run_coroutine_threadsafe(
+        c._handle_message_event(payload), c._bg_loop,
+    )
+    fut.result(timeout=5)
+    # Give the safety pipeline's batch debounce time to fire + handler to run.
+    await asyncio.sleep(1.0)
+    assert len(got) == 1, f"user handler never fired; got={got}"
+    assert got[0].content.text == "hello world"
+    assert got[0].conversation.chat_id == "oc_p2p"
+
+
+# ---- sender._gather_buffer URL path with SSRF guard ------------------------
+
+
+@pytest.mark.asyncio
+async def test_outbound_url_source_blocked_by_ssrf_guard_in_flight():
+    """`OutboundImage(source=MediaSource(kind='url', url=<private>))` must be
+    stopped by the SSRF guard before any httpx.get.
+
+    ``gather_buffer`` raises a typed
+    :class:`FeishuChannelError(SSRF_BLOCKED)` instead of silently
+    returning ``(None, default)``. Silent drop made SSRF blocks
+    indistinguishable from transient network failures upstream.
+    """
+    from lark_channel.channel.errors import FeishuChannelError, FeishuChannelErrorCode
+    from lark_channel.channel.outbound.media.uploader import gather_buffer as _gather_buffer
+    from lark_channel.channel.types import MediaSource
+
+    # Case 1: no allowlist configured -> hard stop.
+    source = MediaSource(kind="url", url="https://internal.test/secret.png")
+    with pytest.raises(FeishuChannelError) as ei:
+        await _gather_buffer(source, "default.bin")
+    assert ei.value.code == FeishuChannelErrorCode.SSRF_BLOCKED
+
+    # Case 2: allowlist contains a DIFFERENT host than the one being
+    # downloaded → fall through to assert_public_url, DNS resolves to
+    # private IP → blocked. (If the allowlist matched, assert_public_url
+    # would skip DNS checks because the operator explicitly trusts that
+    # hostname.)
+    source2 = MediaSource(kind="url", url="https://evil.test/secret.png")
+    source2._ssrf_allowlist = ["not-evil.test"]  # type: ignore[attr-defined]
+    with patch(
+        "socket.getaddrinfo",
+        return_value=[(socket.AF_INET, 0, 0, "", ("10.0.0.5", 0))],
+    ):
+        with pytest.raises(FeishuChannelError) as ei2:
+            await _gather_buffer(source2, "default.bin")
+    assert ei2.value.code == FeishuChannelErrorCode.SSRF_BLOCKED
+
+
+@pytest.mark.asyncio
+async def test_outbound_file_source_reads_bytes(tmp_path):
+    from lark_channel.channel.outbound.media.uploader import gather_buffer as _gather_buffer
+    from lark_channel.channel.types import MediaSource
+
+    p = tmp_path / "foo.bin"
+    p.write_bytes(b"\x00\x01\x02\x03")
+    data, name = await _gather_buffer(MediaSource(kind="file", path=str(p)), "default.bin")
+    assert data == b"\x00\x01\x02\x03"
+    assert name == "foo.bin"
+
+
+@pytest.mark.asyncio
+async def test_outbound_file_source_missing_path_raises_upload_failed():
+    """Updated semantics: ``gather_buffer`` now raises
+    ``FeishuChannelError(UPLOAD_FAILED)`` when a local file can't be read,
+    instead of silently returning ``(None, default)``. The original OSError
+    is preserved via ``__cause__``. See test_upload_error_propagation.py
+    for the full rationale."""
+    from lark_channel.channel.errors import (
+        FeishuChannelError,
+        FeishuChannelErrorCode,
+    )
+    from lark_channel.channel.outbound.media.uploader import gather_buffer as _gather_buffer
+    from lark_channel.channel.types import MediaSource
+
+    with pytest.raises(FeishuChannelError) as ei:
+        await _gather_buffer(
+            MediaSource(kind="file", path="/nonexistent/path/xyz.bin"),
+            "default.bin",
+        )
+    assert ei.value.code == FeishuChannelErrorCode.UPLOAD_FAILED
+    assert isinstance(ei.value.__cause__, OSError)
diff --git a/lark_channel/channel/tests/test_self_sent.py b/lark_channel/channel/tests/test_self_sent.py
new file mode 100644
index 0000000..f264e8e
--- /dev/null
+++ b/lark_channel/channel/tests/test_self_sent.py
@@ -0,0 +1,115 @@
+"""Self-sent message filter tests."""
+
+import asyncio
+import time
+
+import pytest
+
+from lark_channel.channel.config import InboundConfig, TextBatchConfig
+from lark_channel.channel.safety import SafetyPipeline
+from lark_channel.channel.types import (
+    Conversation,
+    Identity,
+    InboundMessage,
+    TextContent,
+)
+
+
+BOT = "ou_bot"
+USER = "ou_user"
+
+
+def _msg(sender: str, *, message_id: str = "m1") -> InboundMessage:
+    return InboundMessage(
+        id=message_id,
+        create_time=int(time.time() * 1000),
+        conversation=Conversation(chat_id="c1", chat_type="p2p"),
+        sender=Identity(open_id=sender),
+        content=TextContent(text="hi"),
+    )
+
+
+@pytest.mark.asyncio
+async def test_self_sent_dropped_by_default():
+    loop = asyncio.get_running_loop()
+    delivered = []
+    rejects = []
+
+    async def on_message(m): delivered.append(m)
+    def on_reject(r): rejects.append(r)
+
+    pipe = SafetyPipeline(
+        loop=loop,
+        on_message=on_message,
+        on_reject=on_reject,
+        drop_self_sent=True,
+    )
+    pipe.set_bot_open_id(BOT)
+    await pipe.push_message(_msg(BOT))
+    await asyncio.sleep(0.05)
+
+    assert delivered == []
+    assert len(rejects) == 1 and rejects[0].reason == "self_sent"
+
+
+@pytest.mark.asyncio
+async def test_user_sent_passes_through():
+    loop = asyncio.get_running_loop()
+    delivered = []
+    async def on_message(m): delivered.append(m)
+
+    pipe = SafetyPipeline(
+        loop=loop,
+        on_message=on_message,
+        drop_self_sent=True,
+        batch_config=TextBatchConfig(delay_ms=0),
+    )
+    pipe.set_bot_open_id(BOT)
+    await pipe.push_message(_msg(USER))
+    await asyncio.sleep(0.05)
+
+    assert len(delivered) == 1
+
+
+@pytest.mark.asyncio
+async def test_self_sent_passes_when_disabled():
+    loop = asyncio.get_running_loop()
+    delivered = []
+    async def on_message(m): delivered.append(m)
+
+    pipe = SafetyPipeline(
+        loop=loop,
+        on_message=on_message,
+        drop_self_sent=False,
+        batch_config=TextBatchConfig(delay_ms=0),
+    )
+    pipe.set_bot_open_id(BOT)
+    await pipe.push_message(_msg(BOT))
+    await asyncio.sleep(0.05)
+
+    assert len(delivered) == 1
+
+
+@pytest.mark.asyncio
+async def test_self_sent_allowed_when_bot_id_unknown():
+    """Conservative: don't filter until bot identity is resolved."""
+    loop = asyncio.get_running_loop()
+    delivered = []
+    async def on_message(m): delivered.append(m)
+
+    pipe = SafetyPipeline(
+        loop=loop,
+        on_message=on_message,
+        drop_self_sent=True,
+        batch_config=TextBatchConfig(delay_ms=0),
+    )
+    # set_bot_open_id NOT called — identity unknown
+    await pipe.push_message(_msg(BOT))
+    await asyncio.sleep(0.05)
+
+    assert len(delivered) == 1
+
+
+def test_inbound_config_default_drops_self_sent():
+    cfg = InboundConfig()
+    assert cfg.drop_self_sent is True
diff --git a/lark_channel/channel/tests/test_sender.py b/lark_channel/channel/tests/test_sender.py
new file mode 100644
index 0000000..0101eae
--- /dev/null
+++ b/lark_channel/channel/tests/test_sender.py
@@ -0,0 +1,163 @@
+"""End-to-end tests for OutboundSender using a fake driver."""
+
+import json
+from typing import Any, Dict, List
+
+import pytest
+
+from lark_channel.channel.config import OutboundConfig
+from lark_channel.channel.outbound.sender import OutboundSender, SendDriver
+from lark_channel.channel.types import (
+    Identity,
+    MediaSource,
+    OutboundCard,
+    OutboundImage,
+    OutboundPost,
+    OutboundText,
+)
+
+
+def make_driver(responses=None, upload_key="img_xx"):
+    calls: List[Dict[str, Any]] = []
+    responses = responses or []
+    idx = 0
+
+    async def create_message(**kwargs):
+        calls.append({"op": "create", **kwargs})
+        nonlocal idx
+        if idx < len(responses):
+            r = responses[idx]
+            idx += 1
+            return r
+        return {"code": 0, "msg": "ok", "data": {"message_id": "om_new"}}
+
+    async def reply_message(**kwargs):
+        calls.append({"op": "reply", **kwargs})
+        return {"code": 0, "msg": "ok", "data": {"message_id": "om_reply"}}
+
+    async def upload_image(**kwargs):
+        calls.append({"op": "upload_image", **{k: v for k, v in kwargs.items() if k != "data"}})
+        return {"code": 0, "data": {"image_key": upload_key}}
+
+    driver = SendDriver(
+        create_message=create_message,
+        reply_message=reply_message,
+        upload_image=upload_image,
+    )
+    return driver, calls
+
+
+@pytest.mark.asyncio
+async def test_text_sends_as_text_msg():
+    d, calls = make_driver()
+    s = OutboundSender(d)
+    r = await s.send(OutboundText(text="hello"), receive_id="oc_1")
+    assert r.success is True
+    assert r.message_id == "om_new"
+    payload = json.loads(calls[0]["content"])
+    assert payload == {"text": "hello"}
+    assert calls[0]["msg_type"] == "text"
+
+
+@pytest.mark.asyncio
+async def test_text_with_mentions_prefix_at():
+    d, calls = make_driver()
+    s = OutboundSender(d)
+    await s.send(
+        OutboundText(text="hi", mentions=[Identity(open_id="ou_1", display_name="Alice")]),
+        receive_id="oc_1",
+    )
+    body = json.loads(calls[0]["content"])
+    assert '<at user_id="ou_1">Alice</at>' in body["text"]
+    assert body["text"].endswith(" hi")
+
+
+@pytest.mark.asyncio
+async def test_reply_via_reply_to():
+    d, calls = make_driver()
+    s = OutboundSender(d)
+    r = await s.send(OutboundText(text="hi"), reply_to="om_parent")
+    assert r.success is True
+    assert calls[0]["op"] == "reply"
+    assert calls[0]["message_id"] == "om_parent"
+
+
+@pytest.mark.asyncio
+async def test_chunks_long_text():
+    d, calls = make_driver()
+    s = OutboundSender(d, OutboundConfig(text_chunk_limit=10, chunk_mode="none"))
+    await s.send(OutboundText(text="a" * 25), receive_id="oc_1")
+    # expect 3 chunks => 3 create_message calls
+    create_calls = [c for c in calls if c["op"] == "create"]
+    assert len(create_calls) == 3
+
+
+@pytest.mark.asyncio
+async def test_post_from_markdown_emits_post_msg():
+    d, calls = make_driver()
+    s = OutboundSender(d)
+    r = await s.send(OutboundPost(markdown="**bold**"), receive_id="oc_1")
+    assert r.success is True
+    assert calls[0]["msg_type"] == "post"
+    content = json.loads(calls[0]["content"])
+    # Feishu API expects {zh_cn: {...}} directly — NO outer {"post": ...} wrapper.
+    # Wrapping with "post" causes server error 230001 (invalid message content).
+    assert "post" not in content
+    zh = content["zh_cn"]
+    assert zh["content"][0][0]["text"] == "bold"
+
+
+@pytest.mark.asyncio
+async def test_card_sends_as_interactive():
+    d, calls = make_driver()
+    s = OutboundSender(d)
+    r = await s.send(OutboundCard(card={"schema": "2.0", "body": {"elements": []}}), receive_id="oc_1")
+    assert r.success is True
+    assert calls[0]["msg_type"] == "interactive"
+    body = json.loads(calls[0]["content"])
+    assert body["schema"] == "2.0"
+
+
+@pytest.mark.asyncio
+async def test_image_url_uploads_first():
+    d, calls = make_driver()
+    s = OutboundSender(d)
+    # buffer source skips network entirely
+    r = await s.send(
+        OutboundImage(source=MediaSource(kind="buffer", buffer=b"png_bytes")),
+        receive_id="oc_1",
+    )
+    assert r.success is True
+    ops = [c["op"] for c in calls]
+    assert ops[0] == "upload_image"
+    assert ops[1] == "create"
+
+
+@pytest.mark.asyncio
+async def test_error_response_classified():
+    d, calls = make_driver(responses=[{"code": 230002, "msg": "not exist"}])
+    s = OutboundSender(d)
+    r = await s.send(OutboundText(text="hi"), receive_id="oc_1")
+    assert r.success is False
+    assert r.error.code.value == "target_revoked"
+    assert r.error.retryable is False
+
+
+@pytest.mark.asyncio
+async def test_send_failure_log_redacts_request_content(caplog):
+    d, calls = make_driver(responses=[{"code": 230001, "msg": "bad"}])
+    s = OutboundSender(d)
+
+    await s.send(OutboundText(text="secret customer payload"), receive_id="oc_1")
+
+    assert "secret customer payload" not in caplog.text
+    assert "request_content=" not in caplog.text
+    assert "request_content_len=" in caplog.text
+
+
+@pytest.mark.asyncio
+async def test_receive_id_type_auto_detected():
+    d, calls = make_driver()
+    s = OutboundSender(d)
+    await s.send(OutboundText(text="hi"), receive_id="ou_user")
+    assert calls[0]["receive_id_type"] == "open_id"
diff --git a/lark_channel/channel/tests/test_sender_extras.py b/lark_channel/channel/tests/test_sender_extras.py
new file mode 100644
index 0000000..1cddf76
--- /dev/null
+++ b/lark_channel/channel/tests/test_sender_extras.py
@@ -0,0 +1,91 @@
+"""Extra sender tests: on_success hook + markdown table_mode forwarded."""
+
+import json
+
+import pytest
+
+from lark_channel.channel.config import MarkdownConverter, OutboundConfig
+from lark_channel.channel.outbound.sender import OutboundSender, SendDriver
+from lark_channel.channel.types import OutboundPost, OutboundText
+
+
+def _driver():
+    async def create_message(**kwargs):
+        return {"code": 0, "data": {"message_id": "om_abc"}}
+
+    async def reply_message(**kwargs):  # pragma: no cover - unused here
+        return {"code": 0}
+
+    return SendDriver(create_message=create_message, reply_message=reply_message)
+
+
+@pytest.mark.asyncio
+async def test_on_success_hook_fires_with_message_id():
+    got = []
+    s = OutboundSender(_driver())
+    s._on_success = lambda mid: got.append(mid)
+    r = await s.send(OutboundText(text="hi"), receive_id="oc_1")
+    assert r.success
+    assert got == ["om_abc"]
+
+
+@pytest.mark.asyncio
+async def test_on_success_hook_not_called_on_failure():
+    async def create_fail(**kwargs):
+        return {"code": 99991663, "msg": "token"}
+
+    async def noop(**kwargs):
+        return {"code": 0}
+
+    got = []
+    s = OutboundSender(SendDriver(create_message=create_fail, reply_message=noop))
+    s._on_success = lambda mid: got.append(mid)
+    r = await s.send(OutboundText(text="hi"), receive_id="oc_1")
+    assert r.success is False
+    assert got == []
+
+
+@pytest.mark.asyncio
+async def test_table_mode_forwarded_to_markdown():
+    captured = []
+
+    async def create_message(**kwargs):
+        captured.append(kwargs)
+        return {"code": 0, "data": {"message_id": "om_abc"}}
+
+    async def noop(**kwargs):
+        return {"code": 0}
+
+    s = OutboundSender(
+        SendDriver(create_message=create_message, reply_message=noop),
+        OutboundConfig(markdown_converter=MarkdownConverter(table_mode="bullets")),
+    )
+    md = "| name | age |\n|---|---|\n| Alice | 30 |"
+    await s.send(OutboundPost(markdown=md), receive_id="oc_1")
+    body = json.loads(captured[0]["content"])
+    zh = body["zh_cn"]  # Feishu API — content is unwrapped locale map.
+    # bullets mode emits "• name: Alice · age: 30"
+    assert any("Alice" in (run.get("text") or "") and "•" in (run.get("text") or "") for run in zh["content"][0])
+
+
+@pytest.mark.asyncio
+async def test_table_mode_off_preserves_raw_table_lines():
+    captured = []
+
+    async def create_message(**kwargs):
+        captured.append(kwargs)
+        return {"code": 0, "data": {"message_id": "om_abc"}}
+
+    async def noop(**kwargs):
+        return {"code": 0}
+
+    s = OutboundSender(
+        SendDriver(create_message=create_message, reply_message=noop),
+        OutboundConfig(markdown_converter=MarkdownConverter(table_mode="off")),
+    )
+    md = "| a | b |\n|---|---|\n| 1 | 2 |"
+    await s.send(OutboundPost(markdown=md), receive_id="oc_1")
+    body = json.loads(captured[0]["content"])
+    zh = body["zh_cn"]  # Feishu API — content is unwrapped locale map.
+    flat = "".join(run.get("text") or "" for para in zh["content"] for run in para)
+    assert "| a | b |" in flat
diff --git a/lark_channel/channel/tests/test_splitter.py b/lark_channel/channel/tests/test_splitter.py
new file mode 100644
index 0000000..fefa030
--- /dev/null
+++ b/lark_channel/channel/tests/test_splitter.py
@@ -0,0 +1,42 @@
+"""Code-fence-aware Markdown splitter tests."""
+
+from lark_channel.channel.outbound.markdown.splitter import split_with_code_fences
+
+
+def test_short_passthrough():
+    assert split_with_code_fences("hello", limit=100) == ["hello"]
+
+
+def test_fence_preserved_across_split():
+    md = "\n".join([
+        "Intro text",
+        "```python",
+        "print(1)",
+        "print(2)",
+        "print(3)",
+        "print(4)",
+        "print(5)",
+        "```",
+        "Done",
+    ])
+    chunks = split_with_code_fences(md, limit=40)
+    assert len(chunks) >= 2
+    for c in chunks:
+        # Every chunk that starts with code should properly close
+        fences = c.count("```")
+        assert fences % 2 == 0, f"unbalanced fences in chunk: {c!r}"
+
+
+def test_heading_starts_chunk_when_buffer_75_full():
+    md = "\n".join(["a" * 85, "# Heading", "body text"])
+    chunks = split_with_code_fences(md, limit=100)
+    # Heading should land at the start of a later chunk, not end of an earlier one
+    heading_first = [i for i, c in enumerate(chunks) if c.startswith("# Heading")]
+    assert heading_first, chunks
+
+
+def test_hard_overflow_single_line():
+    very_long = "x" * 250
+    chunks = split_with_code_fences(very_long, limit=100)
+    # Single-line cannot be split, but splitter should still complete (chunk may exceed limit)
+    assert "".join(chunks) == very_long
diff --git a/lark_channel/channel/tests/test_ssrf_guard.py b/lark_channel/channel/tests/test_ssrf_guard.py
new file mode 100644
index 0000000..dd30aa5
--- /dev/null
+++ b/lark_channel/channel/tests/test_ssrf_guard.py
@@ -0,0 +1,63 @@
+"""SSRF guard tests — pure local asserts, no network hits."""
+
+import socket
+from unittest.mock import patch
+
+import pytest
+
+from lark_channel.channel.errors import FeishuChannelErrorCode, FeishuChannelError
+from lark_channel.channel.outbound.media.ssrf_guard import assert_public_url, _ipv4_blocked, _ipv6_blocked
+
+
+def test_private_ipv4_cidrs_blocked():
+    for ip in ("10.0.0.1", "127.0.0.1", "169.254.169.254", "172.16.5.1", "192.168.1.1", "100.64.1.1"):
+        assert _ipv4_blocked(ip) is True, ip
+
+
+def test_public_ipv4_allowed():
+    for ip in ("1.1.1.1", "8.8.8.8", "93.184.216.34"):
+        assert _ipv4_blocked(ip) is False, ip
+
+
+def test_ipv6_loopback_and_ula_blocked():
+    assert _ipv6_blocked("::1") is True
+    assert _ipv6_blocked("fe80::1") is True
+    assert _ipv6_blocked("fd00::1") is True  # ULA
+    assert _ipv6_blocked("fc00::1") is True
+
+
+def test_ipv6_public_allowed():
+    assert _ipv6_blocked("2606:4700:4700::1111") is False
+
+
+@pytest.mark.asyncio
+async def test_non_http_protocol_rejected():
+    with pytest.raises(FeishuChannelError) as ei:
+        await assert_public_url("file:///etc/passwd")
+    assert ei.value.code == FeishuChannelErrorCode.SSRF_BLOCKED
+
+
+@pytest.mark.asyncio
+async def test_private_hostname_rejected():
+    with patch("socket.getaddrinfo", return_value=[
+        (socket.AF_INET, 0, 0, "", ("10.0.0.5", 0)),
+    ]):
+        with pytest.raises(FeishuChannelError) as ei:
+            await assert_public_url("https://internal.example")
+        assert ei.value.code == FeishuChannelErrorCode.SSRF_BLOCKED
+        assert "10.0.0.5" in str(ei.value)
+
+
+@pytest.mark.asyncio
+async def test_public_hostname_allowed():
+    with patch("socket.getaddrinfo", return_value=[
+        (socket.AF_INET, 0, 0, "", ("93.184.216.34", 0)),
+    ]):
+        await assert_public_url("https://example.com")  # no raise
+
+
+@pytest.mark.asyncio
+async def test_allowlist_bypasses_dns_check():
+    # Allowlist entry means we don't even call getaddrinfo
+    with patch("socket.getaddrinfo", side_effect=AssertionError("should not be called")):
+        await assert_public_url("https://internal.test", allowlist=["internal.test"])
diff --git a/lark_channel/channel/tests/test_streaming_primitives.py b/lark_channel/channel/tests/test_streaming_primitives.py
new file mode 100644
index 0000000..cce0e0b
--- /dev/null
+++ b/lark_channel/channel/tests/test_streaming_primitives.py
@@ -0,0 +1,394 @@
+"""Unit tests for UpdateQueue / merge_streaming_text / Throttle /
+MarkdownStreamController / CardStreamController."""
+
+import asyncio
+from typing import Any, Dict, List
+
+import pytest
+
+from lark_channel.channel.outbound.streaming import (
+    Throttle,
+    UpdateQueue,
+    merge_streaming_text,
+)
+from lark_channel.channel.outbound.streaming.card_stream import CardStreamController
+from lark_channel.channel.outbound.streaming.markdown_stream import MarkdownStreamController
+
+
+# ---- merge_streaming_text ---------------------------------------------------
+
+
+def test_merge_accumulated_uses_next():
+    assert merge_streaming_text("Hello", "Hello world") == "Hello world"
+
+
+def test_merge_delta_concatenates():
+    assert merge_streaming_text("Hello", " world") == "Hello world"
+
+
+def test_merge_rewound_keeps_prev():
+    assert merge_streaming_text("Hello world", "Hello") == "Hello world"
+
+
+def test_merge_overlap_detected():
+    assert merge_streaming_text("Hello wo", "world!") == "Hello world!"
+
+
+def test_merge_no_overlap_falls_back_to_concat():
+    assert merge_streaming_text("abc", "xyz") == "abcxyz"
+
+
+def test_merge_empty_inputs():
+    assert merge_streaming_text("", "hi") == "hi"
+    assert merge_streaming_text("hi", "") == "hi"
+
+
+# ---- UpdateQueue ------------------------------------------------------------
+#
+# UpdateQueue is coalescing: at most 1 running + 1 pending. A burst of
+# enqueues while a task is running collapses down to a single "latest"
+# pending. See update_queue.py docstring for the semantic contract and
+# the intentional divergence from node-sdk's strict FIFO.
+
+
+@pytest.mark.asyncio
+async def test_update_queue_runs_sequentially_when_not_bursted():
+    """When enqueues are spaced out (each runs to completion before the
+    next is enqueued), the queue behaves like a simple FIFO."""
+    q = UpdateQueue()
+    log: List[str] = []
+
+    async def mk(name, sleep):
+        async def t():
+            log.append(f"{name}:start")
+            await asyncio.sleep(sleep)
+            log.append(f"{name}:end")
+        return t
+
+    for name, sleep in (("A", 0.01), ("B", 0.01), ("C", 0.01)):
+        q.enqueue(await mk(name, sleep))
+        await q.drain()
+    assert log == ["A:start", "A:end", "B:start", "B:end", "C:start", "C:end"]
+
+
+@pytest.mark.asyncio
+async def test_update_queue_coalesces_pending_bursts():
+    """Burst-enqueue while a task is running: only the LAST enqueued task
+    actually runs after the current one finishes. Intermediates are dropped.
+    """
+    q = UpdateQueue()
+    ran: List[str] = []
+
+    async def t_slow():
+        ran.append("A:start")
+        await asyncio.sleep(0.05)  # long enough to enqueue B, C, D during A
+        ran.append("A:end")
+
+    def mk(name):
+        async def t():
+            ran.append(name)
+        return t
+
+    q.enqueue(t_slow)
+    # Let A actually start.
+    await asyncio.sleep(0)
+    # Burst B, C, D while A is mid-flight — only D should survive.
+    q.enqueue(mk("B"))
+    q.enqueue(mk("C"))
+    q.enqueue(mk("D"))
+    await q.drain()
+
+    assert ran == ["A:start", "A:end", "D"], (
+        f"expected A then only D (coalesced), got {ran}"
+    )
+
+
+@pytest.mark.asyncio
+async def test_update_queue_continues_after_failure():
+    """A raising task is logged + skipped; a subsequent enqueue still runs."""
+    q = UpdateQueue()
+    ran: List[str] = []
+
+    async def fail():
+        ran.append("fail:start")
+        raise RuntimeError("boom")
+
+    async def success():
+        ran.append("success:ran")
+
+    q.enqueue(fail)
+    await asyncio.sleep(0)  # let fail() start
+    q.enqueue(success)
+    await q.drain()
+    assert ran == ["fail:start", "success:ran"]
+
+
+@pytest.mark.asyncio
+async def test_update_queue_drain_with_no_enqueued_tasks_returns_immediately():
+    q = UpdateQueue()
+    # No enqueue — drain should be a no-op.
+    await q.drain()
+
+
+@pytest.mark.asyncio
+async def test_update_queue_enqueue_after_drain_still_works():
+    """After a drain, a fresh enqueue should still run (queue not 'closed')."""
+    q = UpdateQueue()
+    ran: List[str] = []
+
+    async def t(name):
+        ran.append(name)
+
+    q.enqueue(lambda: t("first"))
+    await q.drain()
+    q.enqueue(lambda: t("second"))
+    await q.drain()
+    assert ran == ["first", "second"]
+
+
+# ---- Throttle ---------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_throttle_fires_on_chars_threshold():
+    fires = []
+    t = Throttle(min_ms=1000, min_chars=10, on_fire=lambda: fires.append(1))
+    t.note(5)
+    assert fires == []  # below char threshold, timer armed
+    t.note(10)  # pending=15 ≥ 10 → immediate fire
+    assert len(fires) == 1
+
+
+@pytest.mark.asyncio
+async def test_throttle_fires_on_time_threshold():
+    fires = []
+    t = Throttle(min_ms=50, min_chars=1000, on_fire=lambda: fires.append(1))
+    t.note(5)
+    await asyncio.sleep(0.1)
+    assert len(fires) == 1
+
+
+@pytest.mark.asyncio
+async def test_throttle_flush_now_forces_fire():
+    fires = []
+    t = Throttle(min_ms=1000, min_chars=1000, on_fire=lambda: fires.append(1))
+    t.note(5)
+    t.flush_now()
+    assert len(fires) == 1
+
+
+@pytest.mark.asyncio
+async def test_throttle_dispose_prevents_fire():
+    fires = []
+    t = Throttle(min_ms=30, min_chars=1000, on_fire=lambda: fires.append(1))
+    t.note(5)
+    t.dispose()
+    await asyncio.sleep(0.08)
+    assert fires == []
+
+
+# ---- MarkdownStreamController (cardkit preallocation flow) -----------------
+
+
+def _make_cardkit_fakes():
+    """Return 4 fake cardkit dependencies + capture storage.
+
+    Mirrors node's protocol: create_card_instance → send_card_by_reference →
+    update_card_element_content (many times, seq-ordered) → finish_streaming_card.
+    """
+    state = {
+        "created_specs": [],
+        "sent_refs": [],
+        "elem_updates": [],  # list of (card_id, element_id, content, seq)
+        "finishes": [],      # list of (card_id, seq)
+    }
+
+    async def create_card_instance(spec):
+        state["created_specs"].append(spec)
+        return "card_abc"
+
+    class _FakeSendResult:
+        def __init__(self, mid): self.message_id = mid
+
+    async def send_card_by_reference(to, card_id, *, receive_id_type=None,
+                                     reply_to=None, reply_in_thread=None):
+        state["sent_refs"].append({
+            "to": to, "card_id": card_id,
+            "receive_id_type": receive_id_type,
+            "reply_to": reply_to, "reply_in_thread": reply_in_thread,
+        })
+        return _FakeSendResult("om_sent")
+
+    async def update_card_element_content(card_id, element_id, content, seq):
+        state["elem_updates"].append((card_id, element_id, content, seq))
+
+    async def finish_streaming_card(card_id, seq):
+        state["finishes"].append((card_id, seq))
+
+    return state, (
+        create_card_instance, send_card_by_reference,
+        update_card_element_content, finish_streaming_card,
+    )
+
+
+def _mk_controller(deps, *, to="oc_1", rit="chat_id"):
+    cci, scbr, ucec, fsc = deps
+    return MarkdownStreamController(
+        to=to, receive_id_type=rit, reply_to=None, reply_in_thread=None,
+        create_card_instance=cci,
+        send_card_by_reference=scbr,
+        update_card_element_content=ucec,
+        finish_streaming_card=fsc,
+        min_ms=10, min_chars=3,
+    )
+
+
+@pytest.mark.asyncio
+async def test_markdown_stream_creates_then_element_updates():
+    state, deps = _make_cardkit_fakes()
+    ctl = _mk_controller(deps)
+
+    async def producer(s):
+        await s.append("Hello ")
+        await s.append("world")
+        await s.append("!")
+
+    mid = await ctl.run(producer)
+    assert mid == "om_sent"
+
+    # Creation happened exactly once, with a card spec containing a markdown
+    # element whose element_id matches what updates target.
+    assert len(state["created_specs"]) == 1
+    spec = state["created_specs"][0]
+    elements = spec["body"]["elements"]
+    assert len(elements) == 1
+    assert elements[0]["tag"] == "markdown"
+    assert elements[0]["element_id"] == "stream_md"
+    assert spec["config"]["streaming_mode"] is True
+
+    # The reference send used the created card_id and the correct routing.
+    assert len(state["sent_refs"]) == 1
+    assert state["sent_refs"][0]["card_id"] == "card_abc"
+    assert state["sent_refs"][0]["receive_id_type"] == "chat_id"
+
+    # At least one element update fired; all target the same (card_id, element_id).
+    assert len(state["elem_updates"]) >= 1
+    assert all(cid == "card_abc" and eid == "stream_md"
+               for (cid, eid, _c, _s) in state["elem_updates"])
+
+    # Sequence numbers strictly increase — gaps are allowed because the
+    # UpdateQueue is coalescing: when a snapshot is enqueued while another
+    # is already pending, the pending one is replaced and its seq is
+    # effectively skipped. The server orders by seq regardless.
+    seqs = [s for (_c, _e, _txt, s) in state["elem_updates"]]
+    assert seqs[0] >= 1, f"first seq should be >= 1, got {seqs}"
+    assert all(later > earlier for earlier, later in zip(seqs, seqs[1:])), (
+        f"seqs must be strictly increasing, got {seqs}"
+    )
+
+    # Last element-update content contains the full accumulated text.
+    assert "Hello world!" in state["elem_updates"][-1][2]
+
+    # finish_streaming_card called exactly once, with a seq greater than
+    # any element-update seq (and greater than the controller's internal
+    # counter which increments for every enqueue, coalesced or not).
+    assert len(state["finishes"]) == 1
+    finish_card_id, finish_seq = state["finishes"][0]
+    assert finish_card_id == "card_abc"
+    assert finish_seq > seqs[-1], (
+        f"finish seq ({finish_seq}) must be after last update seq ({seqs[-1]})"
+    )
+
+
+@pytest.mark.asyncio
+async def test_markdown_stream_sequence_never_rewinds():
+    """Seq is strictly monotonic even if many appends fire many throttles."""
+    state, deps = _make_cardkit_fakes()
+    ctl = _mk_controller(deps, to="oc_1")
+
+    async def producer(s):
+        for i in range(10):
+            await s.append(f"chunk-{i:02d} ")
+            await asyncio.sleep(0.02)
+
+    await ctl.run(producer)
+
+    seqs = [s for (_c, _e, _txt, s) in state["elem_updates"]]
+    assert seqs, "no element updates fired"
+    assert seqs == sorted(seqs) and len(set(seqs)) == len(seqs)
+    # finish seq strictly greater than every update seq.
+    assert state["finishes"][0][1] > max(seqs)
+
+
+@pytest.mark.asyncio
+async def test_markdown_stream_error_appends_footer_then_finishes():
+    state, deps = _make_cardkit_fakes()
+    ctl = _mk_controller(deps)
+
+    async def producer(s):
+        await s.append("some content")
+        raise RuntimeError("llm failure")
+
+    with pytest.raises(RuntimeError):
+        await ctl.run(producer)
+
+    assert state["elem_updates"], "no element updates fired"
+    last_content = state["elem_updates"][-1][2]
+    assert "some content" in last_content
+    assert "generation interrupted" in last_content
+    # Even on error path, finish is still called.
+    assert len(state["finishes"]) == 1
+
+
+# ---- CardStreamController --------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_card_stream_update_and_transform_function():
+    patched: List[Dict[str, Any]] = []
+
+    async def ensure_created(card):
+        return "om_c"
+
+    async def patch_card(mid, card):
+        patched.append(card)
+
+    initial = {"body": {"elements": [{"tag": "markdown", "content": "start"}]}}
+    ctl = CardStreamController(
+        initial=initial,
+        ensure_created=ensure_created, patch_card=patch_card,
+        min_ms=10, min_chars=1,
+    )
+
+    async def producer(s):
+        await s.update({"body": {"elements": [{"tag": "markdown", "content": "step 1"}]}})
+        await s.update(lambda c: {**c, "body": {"elements": [{"tag": "markdown", "content": "step 2"}]}})
+
+    await ctl.run(producer)
+    last = patched[-1]
+    assert last["body"]["elements"][0]["content"] == "step 2"
+
+
+@pytest.mark.asyncio
+async def test_card_stream_error_appends_footer_element():
+    patched: List[Dict[str, Any]] = []
+
+    async def ensure_created(card):
+        return "om_c"
+
+    async def patch_card(mid, card):
+        patched.append(card)
+
+    ctl = CardStreamController(
+        initial={"body": {"elements": []}},
+        ensure_created=ensure_created, patch_card=patch_card,
+    )
+
+    async def producer(s):
+        await s.update({"body": {"elements": [{"tag": "markdown", "content": "x"}]}})
+        raise ValueError("mid-stream fail")
+
+    with pytest.raises(ValueError):
+        await ctl.run(producer)
+    last_elements = patched[-1]["body"]["elements"]
+    assert any("generation interrupted" in (e.get("content") or "") for e in last_elements)
diff --git a/lark_channel/channel/tests/test_token_store.py b/lark_channel/channel/tests/test_token_store.py
new file mode 100644
index 0000000..e7d2bf9
--- /dev/null
+++ b/lark_channel/channel/tests/test_token_store.py
@@ -0,0 +1,45 @@
+"""TokenStore tests."""
+
+import os
+import tempfile
+import warnings
+
+import pytest
+
+from lark_channel.channel.auth.token_store import FileTokenStore, InMemoryTokenStore
+from lark_channel.channel.types import UAT
+
+
+@pytest.mark.asyncio
+async def test_inmem_roundtrip():
+    s = InMemoryTokenStore()
+    await s.set("u1", UAT(access_token="t", scopes=["im:message"]))
+    got = await s.get("u1")
+    assert got is not None and got.access_token == "t" and got.scopes == ["im:message"]
+    await s.delete("u1")
+    assert await s.get("u1") is None
+
+
+@pytest.mark.asyncio
+async def test_file_store_persists_across_instances():
+    with tempfile.TemporaryDirectory() as tmp:
+        path = os.path.join(tmp, "toks.json")
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            s = FileTokenStore(path)
+            await s.set("u2", UAT(access_token="abc", scopes=["im:message"]))
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            s2 = FileTokenStore(path)
+        got = await s2.get("u2")
+        assert got is not None and got.access_token == "abc"
+
+
+@pytest.mark.asyncio
+async def test_file_store_warns():
+    with tempfile.TemporaryDirectory() as tmp:
+        path = os.path.join(tmp, "t.json")
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            FileTokenStore(path)
+            assert any("not for production" in str(x.message).lower() for x in w)
diff --git a/lark_channel/channel/tests/test_types_aliases.py b/lark_channel/channel/tests/test_types_aliases.py
new file mode 100644
index 0000000..f8d00b2
--- /dev/null
+++ b/lark_channel/channel/tests/test_types_aliases.py
@@ -0,0 +1,129 @@
+"""Property aliases on `InboundMessage`.
+
+Verifies that `msg.message_id` / `msg.chat_id` / `msg.sender_id` /
+`msg.chat_type` / `msg.reply_to_message_id` all project the expected values
+from the underlying dataclasses.
+"""
+
+from lark_channel.channel.types import (
+    Conversation,
+    Identity,
+    InboundMessage,
+    ReplyRef,
+    ResourceDescriptor,
+    ResourceType,
+)
+
+
+def test_message_id_property_aliases_id():
+    msg = InboundMessage(
+        id="om_abc", create_time=0,
+        conversation=Conversation(chat_id="oc_1", chat_type="p2p"),
+        sender=Identity(open_id="ou_1"),
+    )
+    assert msg.message_id == "om_abc"
+
+
+def test_chat_id_and_chat_type_properties():
+    msg = InboundMessage(
+        id="om", create_time=0,
+        conversation=Conversation(chat_id="oc_X", chat_type="group"),
+        sender=Identity(open_id="ou_1"),
+    )
+    assert msg.chat_id == "oc_X"
+    assert msg.chat_type == "group"
+
+
+def test_sender_id_and_sender_name():
+    msg = InboundMessage(
+        id="om", create_time=0,
+        conversation=Conversation(chat_id="oc_1", chat_type="p2p"),
+        sender=Identity(open_id="ou_s", display_name="Alice"),
+    )
+    assert msg.sender_id == "ou_s"
+    assert msg.sender_name == "Alice"
+
+
+def test_reply_to_message_id_none_when_no_reply():
+    msg = InboundMessage(
+        id="om", create_time=0,
+        conversation=Conversation(chat_id="oc_1", chat_type="p2p"),
+        sender=Identity(open_id="ou_1"),
+    )
+    assert msg.reply_to_message_id is None
+
+
+def test_reply_to_message_id_populated_from_reply():
+    msg = InboundMessage(
+        id="om", create_time=0,
+        conversation=Conversation(chat_id="oc_1", chat_type="p2p"),
+        sender=Identity(open_id="ou_1"),
+        reply=ReplyRef(message_id="om_parent"),
+    )
+    assert msg.reply_to_message_id == "om_parent"
+
+
+def test_default_content_text_and_resources_empty():
+    msg = InboundMessage(
+        id="om", create_time=0,
+        conversation=Conversation(chat_id="oc_1", chat_type="p2p"),
+        sender=Identity(open_id="ou_1"),
+    )
+    assert msg.content_text == ""
+    assert msg.resources == []
+    assert msg.mentioned_bot is False
+
+
+def test_resource_descriptor_fields():
+    r = ResourceDescriptor(
+        type="video",
+        file_key="v_x",
+        file_name="clip.mp4",
+        duration_ms=1500,
+        cover_image_key="img_cover",
+    )
+    assert r.type == "video"
+    assert r.duration_ms == 1500
+
+
+def test_resource_type_values_match_node_spec():
+    # The canonical Node-spec set of resource types
+    assert set(ResourceType.__args__) == {"image", "file", "audio", "video", "sticker"}
+
+
+def test_inbound_message_batched_sources_default_none():
+    from lark_channel.channel import InboundMessage, Conversation, Identity, TextContent
+    m = InboundMessage(
+        id="m1",
+        create_time=0,
+        conversation=Conversation(chat_id="c1", chat_type="p2p"),
+        sender=Identity(open_id="ou_x"),
+        content=TextContent(text="hi"),
+    )
+    assert m.batched_sources is None
+
+
+def test_inbound_message_positional_raw_content_type_compatibility():
+    from lark_channel.channel import InboundMessage, Conversation, Identity, TextContent
+
+    batched = []
+    m = InboundMessage(
+        "m1",
+        0,
+        Conversation(chat_id="c1", chat_type="p2p"),
+        Identity(open_id="ou_x"),
+        [],
+        False,
+        None,
+        TextContent(text="hi"),
+        {},
+        "",
+        [],
+        False,
+        "text",
+        batched,
+    )
+
+    assert m.raw_content_type == "text"
+    assert m.batched_sources is batched
+    assert m.chat_mode is None
diff --git a/lark_channel/channel/tests/test_upload_error_propagation.py b/lark_channel/channel/tests/test_upload_error_propagation.py
new file mode 100644
index 0000000..a050c98
--- /dev/null
+++ b/lark_channel/channel/tests/test_upload_error_propagation.py
@@ -0,0 +1,238 @@
+"""Regression tests for upload error propagation.
+
+Upload failures such as server rejection, missing local files, URL download
+errors, and wrong allowlists surface as typed :class:`FeishuChannelError`
+instances with useful context. The sender maps those errors into
+``SendResult.fail(SendError(code=e.code, ...))``.
+"""
+
+from unittest.mock import AsyncMock
+
+import pytest
+
+from lark_channel.channel.errors import FeishuChannelError, FeishuChannelErrorCode
+from lark_channel.channel.outbound.media.uploader import (
+    gather_buffer,
+    resolve_media_key,
+)
+from lark_channel.channel.outbound.sender import SendDriver
+from lark_channel.channel.types import MediaSource
+
+
+# ---------------------------------------------------------------------------
+# gather_buffer — typed errors instead of silent (None, default)
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_gather_buffer_missing_local_file_raises_upload_failed(tmp_path):
+    """File doesn't exist → ``UPLOAD_FAILED`` carrying the OSError cause +
+    the actual file path in the error context."""
+    nonexistent = str(tmp_path / "does_not_exist.png")
+    source = MediaSource(kind="file", path=nonexistent)
+    with pytest.raises(FeishuChannelError) as ei:
+        await gather_buffer(source, "fallback.bin")
+    err = ei.value
+    assert err.code == FeishuChannelErrorCode.UPLOAD_FAILED
+    assert nonexistent in str(err)
+    # Concrete OSError preserved via ``from e`` — callers can inspect.
+    assert err.__cause__ is not None
+    assert isinstance(err.__cause__, OSError)
+    # Context carries diagnostics.
+    assert err.context.get("path") == nonexistent
+    assert err.context.get("source_kind") == "file"
+
+
+@pytest.mark.asyncio
+async def test_gather_buffer_url_download_network_error_raises_upload_failed(
+    monkeypatch,
+):
+    """URL reachable per SSRF guard + allowlist, but httpx raises mid-
+    download → ``UPLOAD_FAILED`` with the original exception as ``__cause__``."""
+    source = MediaSource(kind="url", url="https://cdn.ok.test/a.png")
+    source._ssrf_allowlist = ["cdn.ok.test"]  # type: ignore[attr-defined]
+
+    # When the allowlist short-circuits assert_public_url, we still end up
+    # inside the httpx block. Stub httpx.AsyncClient to raise.
+    class _BoomClient:
+        def __init__(self, *a, **kw):
+            pass
+        async def __aenter__(self):
+            return self
+        async def __aexit__(self, *a):
+            return False
+        def stream(self, method, url):
+            raise RuntimeError("simulated network blow-up")
+
+    import httpx
+    monkeypatch.setattr(httpx, "AsyncClient", _BoomClient)
+
+    with pytest.raises(FeishuChannelError) as ei:
+        await gather_buffer(source, "fallback.bin")
+    err = ei.value
+    assert err.code == FeishuChannelErrorCode.UPLOAD_FAILED
+    assert "cdn.ok.test" in str(err)
+    assert err.__cause__ is not None
+    assert "simulated network blow-up" in str(err.__cause__)
+
+
+@pytest.mark.asyncio
+async def test_gather_buffer_url_errors_redact_sensitive_url_parts(monkeypatch):
+    source = MediaSource(
+        kind="url",
+        url="https://user:pass@cdn.ok.test/a.png?token=secret#frag",
+    )
+    source._ssrf_allowlist = ["cdn.ok.test"]  # type: ignore[attr-defined]
+
+    class _BoomClient:
+        def __init__(self, *a, **kw):
+            pass
+
+        async def __aenter__(self):
+            return self
+
+        async def __aexit__(self, *a):
+            return False
+
+        def stream(self, method, url):
+            raise RuntimeError("simulated network blow-up")
+
+    import httpx
+    monkeypatch.setattr(httpx, "AsyncClient", _BoomClient)
+
+    with pytest.raises(FeishuChannelError) as ei:
+        await gather_buffer(source, "fallback.bin")
+
+    rendered = str(ei.value)
+    assert "cdn.ok.test" in rendered
+    assert "token=secret" not in rendered
+    assert "user:pass" not in rendered
+    assert ei.value.context.get("url") == "https://cdn.ok.test/a.png"
+
+
+# ---------------------------------------------------------------------------
+# resolve_media_key — server-side upload rejection propagates code + msg
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_resolve_media_key_propagates_server_rejection_code_and_msg():
+    """When the Lark backend rejects an upload with ``code=99991663`` or
+    similar, the caller sees
+    ``SendResult.fail(UPLOAD_FAILED, hint="... code=99991663 msg=token invalid")``
+    and the context dict has raw_code/raw_msg."""
+    fake_upload_image = AsyncMock(
+        return_value={"code": 99991663, "msg": "invalid access_token", "data": {}}
+    )
+    driver = SendDriver(
+        create_message=AsyncMock(),
+        reply_message=AsyncMock(),
+        upload_image=fake_upload_image,
+        upload_file=AsyncMock(),
+    )
+    src = MediaSource(kind="buffer", buffer=b"\x89PNG")
+    with pytest.raises(FeishuChannelError) as ei:
+        await resolve_media_key(driver, src, "image")
+    err = ei.value
+    assert err.code == FeishuChannelErrorCode.UPLOAD_FAILED
+    assert "99991663" in str(err)
+    assert "invalid access_token" in str(err)
+    assert err.context.get("raw_code") == 99991663
+    assert err.context.get("raw_msg") == "invalid access_token"
+
+
+@pytest.mark.asyncio
+async def test_resolve_media_key_propagates_network_error():
+    """Driver's upload coroutine raises (simulates DNS / TLS / socket
+    errors). ``resolve_media_key`` wraps into UPLOAD_FAILED with the
+    original exception as ``__cause__`` so tracebacks show the chain."""
+    fake_upload_file = AsyncMock(side_effect=ConnectionError("DNS resolve failed"))
+    driver = SendDriver(
+        create_message=AsyncMock(),
+        reply_message=AsyncMock(),
+        upload_image=AsyncMock(),
+        upload_file=fake_upload_file,
+    )
+    src = MediaSource(kind="buffer", buffer=b"payload")
+    with pytest.raises(FeishuChannelError) as ei:
+        await resolve_media_key(driver, src, "file", file_name="x.pdf")
+    err = ei.value
+    assert err.code == FeishuChannelErrorCode.UPLOAD_FAILED
+    assert err.__cause__ is not None
+    assert isinstance(err.__cause__, ConnectionError)
+
+
+@pytest.mark.asyncio
+async def test_resolve_media_key_flags_malformed_success_response():
+    """Upload returned ``code=0`` but response has no image_key / file_key.
+    Previously ``resolve_media_key`` returned None silently, so the sender
+    said "empty body". Now it raises UPLOAD_FAILED so the caller can see the
+    real issue (server bug / wrong endpoint / stripped proxy)."""
+    fake_upload_image = AsyncMock(
+        return_value={"code": 0, "msg": "", "data": {"unrelated": "value"}}
+    )
+    driver = SendDriver(
+        create_message=AsyncMock(),
+        reply_message=AsyncMock(),
+        upload_image=fake_upload_image,
+        upload_file=AsyncMock(),
+    )
+    src = MediaSource(kind="buffer", buffer=b"\x89PNG")
+    with pytest.raises(FeishuChannelError) as ei:
+        await resolve_media_key(driver, src, "image")
+    assert ei.value.code == FeishuChannelErrorCode.UPLOAD_FAILED
+    assert "missing image_key / file_key" in str(ei.value)
+
+
+@pytest.mark.asyncio
+async def test_resolve_media_key_missing_uploader_raises():
+    """Driver has no ``upload_image`` / ``upload_file`` (mis-wired
+    construction) → typed error instead of silent None."""
+    driver = SendDriver(
+        create_message=AsyncMock(),
+        reply_message=AsyncMock(),
+        upload_image=None,
+        upload_file=None,
+    )
+    src = MediaSource(kind="buffer", buffer=b"payload")
+    with pytest.raises(FeishuChannelError) as ei:
+        await resolve_media_key(driver, src, "image")
+    assert ei.value.code == FeishuChannelErrorCode.UPLOAD_FAILED
+    assert "media uploader missing" in str(ei.value)
+
+
+# ---------------------------------------------------------------------------
+# End-to-end: sender.send() surfaces the typed error as SendResult.fail
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_send_image_with_server_rejection_surfaces_upload_failed():
+    """The full outbound path: ``channel.send({"image": ...})`` →
+    ``OutboundSender.send`` → ``_materialize`` → ``resolve_media_key`` →
+    server returns non-zero. The caller should see a ``SendResult`` with
+    ``error.code == UPLOAD_FAILED`` and ``hint`` containing the raw code/msg
+    — NOT the old "empty body" catch-all."""
+    from lark_channel.channel import FeishuChannel
+    from lark_channel.channel.errors import FeishuChannelErrorCode as Code
+
+    ch = FeishuChannel(app_id="cli_x", app_secret="s")
+    ch._sender._driver.upload_image = AsyncMock(  # type: ignore[attr-defined]
+        return_value={
+            "code": 99991663,
+            "msg": "invalid access_token",
+            "data": {},
+        }
+    )
+
+    result = await ch.send(
+        "oc_target",
+        {"image": {"source": b"\x89PNG\r\n\x1a\n"}},
+    )
+    assert result.success is False
+    assert result.error is not None
+    assert result.error.code == Code.UPLOAD_FAILED
+    assert "99991663" in (result.error.hint or "")
+    assert "invalid access_token" in (result.error.hint or "")
+    # Ensure the old catch-all is GONE.
+    assert "empty body" not in (result.error.hint or "")
diff --git a/lark_channel/channel/tests/test_upload_media.py b/lark_channel/channel/tests/test_upload_media.py
new file mode 100644
index 0000000..ec978b7
--- /dev/null
+++ b/lark_channel/channel/tests/test_upload_media.py
@@ -0,0 +1,279 @@
+"""Tests for ``FeishuChannel.upload_media`` — public single-shot uploader.
+
+The method wraps the internal ``resolve_media_key`` helper with a narrow,
+type-disciplined surface so consumers can obtain a Feishu ``image_key`` /
+``file_key`` without reaching into ``_sender._driver`` or importing from
+``lark_channel.channel.outbound.media.uploader``.
+
+Contract (B'):
+    - ``source`` must be a :class:`MediaSource` (no str / bytes coercion)
+    - ``kind`` must be ``"image"`` or ``"file"`` (audio/video → ``kind="file"``
+      with ``file_type="opus"`` / ``"mp4"``)
+    - Returns ``str`` on success
+    - Failures raise :class:`FeishuChannelError` (no None fall-through)
+    - SSRF allowlist auto-pulled from ``OutboundConfig.ssrf_allowlist``
+"""
+
+from unittest.mock import AsyncMock
+
+import pytest
+
+from lark_channel.channel import FeishuChannel
+from lark_channel.channel.errors import FeishuChannelError, FeishuChannelErrorCode
+from lark_channel.channel.types import MediaSource
+
+
+def _make_channel(*, ssrf_allowlist=None) -> FeishuChannel:
+    """Channel with deterministic upload mocks; no network."""
+    from lark_channel.channel.config import ChannelConfig, OutboundConfig
+
+    cfg = ChannelConfig(
+        app_id="cli_test",
+        app_secret="s",
+        outbound=OutboundConfig(ssrf_allowlist=ssrf_allowlist),
+    )
+    ch = FeishuChannel(config=cfg)
+    return ch
+
+
+# ---------------------------------------------------------------------------
+# Happy path: each MediaSource kind → corresponding driver call
+# ---------------------------------------------------------------------------
+
+
+async def test_upload_media_buffer_image_returns_image_key():
+    ch = _make_channel()
+    ch._sender._driver.upload_image = AsyncMock(  # type: ignore[attr-defined]
+        return_value={"code": 0, "msg": "", "data": {"image_key": "img_abc"}}
+    )
+
+    key = await ch.upload_media(
+        MediaSource(kind="buffer", buffer=b"\x89PNG\r\n"),
+        kind="image",
+    )
+
+    assert key == "img_abc"
+    ch._sender._driver.upload_image.assert_awaited_once()
+
+
+async def test_upload_media_file_returns_file_key(tmp_path):
+    pdf = tmp_path / "report.pdf"
+    pdf.write_bytes(b"%PDF-1.4 ...")
+    ch = _make_channel()
+    ch._sender._driver.upload_file = AsyncMock(  # type: ignore[attr-defined]
+        return_value={"code": 0, "msg": "", "data": {"file_key": "file_xyz"}}
+    )
+
+    key = await ch.upload_media(
+        MediaSource(kind="file", path=str(pdf)),
+        kind="file",
+        file_name="report.pdf",
+    )
+
+    assert key == "file_xyz"
+    call_kwargs = ch._sender._driver.upload_file.await_args.kwargs
+    assert call_kwargs["file_name"] == "report.pdf"
+    assert call_kwargs["data"] == b"%PDF-1.4 ..."
+
+
+async def test_upload_media_key_passthrough_does_not_upload():
+    ch = _make_channel()
+    ch._sender._driver.upload_image = AsyncMock(  # type: ignore[attr-defined]
+        return_value={"code": 0, "msg": "", "data": {"image_key": "should_not_be_used"}}
+    )
+
+    key = await ch.upload_media(
+        MediaSource(kind="key", key="img_already_uploaded"),
+        kind="image",
+    )
+
+    assert key == "img_already_uploaded"
+    ch._sender._driver.upload_image.assert_not_awaited()
+
+
+async def test_upload_media_audio_threads_file_type_opus(tmp_path):
+    """audio is just 'file' kind with file_type='opus' — caller-decided."""
+    audio = tmp_path / "voice.opus"
+    audio.write_bytes(b"OggS\x00\x02")
+    ch = _make_channel()
+    ch._sender._driver.upload_file = AsyncMock(  # type: ignore[attr-defined]
+        return_value={"code": 0, "msg": "", "data": {"file_key": "file_audio"}}
+    )
+
+    key = await ch.upload_media(
+        MediaSource(kind="file", path=str(audio)),
+        kind="file",
+        file_type="opus",
+    )
+
+    assert key == "file_audio"
+    assert ch._sender._driver.upload_file.await_args.kwargs["file_type"] == "opus"
+
+
+async def test_upload_media_video_threads_file_type_mp4(tmp_path):
+    video = tmp_path / "clip.mp4"
+    video.write_bytes(b"\x00\x00\x00\x18ftypmp42")
+    ch = _make_channel()
+    ch._sender._driver.upload_file = AsyncMock(  # type: ignore[attr-defined]
+        return_value={"code": 0, "msg": "", "data": {"file_key": "file_video"}}
+    )
+
+    key = await ch.upload_media(
+        MediaSource(kind="file", path=str(video)),
+        kind="file",
+        file_type="mp4",
+    )
+
+    assert key == "file_video"
+    assert ch._sender._driver.upload_file.await_args.kwargs["file_type"] == "mp4"
+
+
+# ---------------------------------------------------------------------------
+# Error semantics: raise FeishuChannelError, never return None
+# ---------------------------------------------------------------------------
+
+
+async def test_upload_media_server_rejection_raises_upload_failed():
+    ch = _make_channel()
+    ch._sender._driver.upload_image = AsyncMock(  # type: ignore[attr-defined]
+        return_value={"code": 99991663, "msg": "invalid access_token", "data": {}}
+    )
+
+    with pytest.raises(FeishuChannelError) as ei:
+        await ch.upload_media(
+            MediaSource(kind="buffer", buffer=b"\x89PNG"),
+            kind="image",
+        )
+    assert ei.value.code == FeishuChannelErrorCode.UPLOAD_FAILED
+    assert "99991663" in str(ei.value)
+
+
+async def test_upload_media_missing_local_file_raises_upload_failed(tmp_path):
+    ch = _make_channel()
+    nonexistent = tmp_path / "nope.png"
+
+    with pytest.raises(FeishuChannelError) as ei:
+        await ch.upload_media(
+            MediaSource(kind="file", path=str(nonexistent)),
+            kind="image",
+        )
+    assert ei.value.code == FeishuChannelErrorCode.UPLOAD_FAILED
+
+
+async def test_upload_media_url_without_allowlist_raises_ssrf_blocked():
+    ch = _make_channel(ssrf_allowlist=None)
+
+    with pytest.raises(FeishuChannelError) as ei:
+        await ch.upload_media(
+            MediaSource(kind="url", url="https://attacker.example/x.png"),
+            kind="image",
+        )
+    assert ei.value.code == FeishuChannelErrorCode.SSRF_BLOCKED
+
+
+async def test_upload_media_empty_key_raises_upload_failed():
+    """``MediaSource(kind="key", key="")`` has no uploadable content; the
+    underlying helper returns None for this — the public method must convert
+    that to an explicit ``UPLOAD_FAILED`` so callers don't see ``Optional[str]``.
+    """
+    ch = _make_channel()
+
+    with pytest.raises(FeishuChannelError) as ei:
+        await ch.upload_media(
+            MediaSource(kind="key", key=""),
+            kind="image",
+        )
+    assert ei.value.code == FeishuChannelErrorCode.UPLOAD_FAILED
+
+
+# ---------------------------------------------------------------------------
+# Type discipline: reject str / bytes / wrong kind
+# ---------------------------------------------------------------------------
+
+
+async def test_upload_media_rejects_str_source():
+    ch = _make_channel()
+    with pytest.raises(TypeError, match="MediaSource"):
+        await ch.upload_media("/tmp/x.png", kind="image")  # type: ignore[arg-type]
+
+
+async def test_upload_media_rejects_bytes_source():
+    ch = _make_channel()
+    with pytest.raises(TypeError, match="MediaSource"):
+        await ch.upload_media(b"\x89PNG", kind="image")  # type: ignore[arg-type]
+
+
+async def test_upload_media_rejects_unknown_kind():
+    ch = _make_channel()
+    with pytest.raises(ValueError, match="kind"):
+        await ch.upload_media(
+            MediaSource(kind="buffer", buffer=b"x"),
+            kind="audio",  # type: ignore[arg-type]  # B' rejects audio/video as kind
+        )
+
+
+# ---------------------------------------------------------------------------
+# SSRF allowlist auto-threaded from OutboundConfig
+# ---------------------------------------------------------------------------
+
+
+async def test_upload_media_url_uses_outbound_config_allowlist(monkeypatch):
+    """``OutboundConfig.ssrf_allowlist`` flows through transparently — caller
+    does NOT need to set ``source._ssrf_allowlist`` manually."""
+    ch = _make_channel(ssrf_allowlist=["cdn.ok.test"])
+    ch._sender._driver.upload_image = AsyncMock(  # type: ignore[attr-defined]
+        return_value={"code": 0, "msg": "", "data": {"image_key": "img_url"}}
+    )
+
+    # Stub assert_public_url to a no-op so we don't actually resolve DNS.
+    async def _noop(url, *, allowlist):
+        # The allowlist must be the outbound config's value (not None).
+        assert allowlist == ["cdn.ok.test"]
+
+    from lark_channel.channel.outbound.media import uploader as _uploader_mod
+
+    monkeypatch.setattr(_uploader_mod, "assert_public_url", _noop)
+
+    # Stub httpx.AsyncClient to return a tiny payload.
+    class _FakeResp:
+        headers = {"content-length": "4"}
+
+        def raise_for_status(self):
+            return None
+
+        async def aiter_bytes(self):
+            yield b"data"
+
+    class _FakeStream:
+        def __init__(self, resp):
+            self._resp = resp
+
+        async def __aenter__(self):
+            return self._resp
+
+        async def __aexit__(self, *a):
+            return False
+
+    class _FakeClient:
+        def __init__(self, *a, **kw):
+            pass
+
+        async def __aenter__(self):
+            return self
+
+        async def __aexit__(self, *a):
+            return False
+
+        def stream(self, method, url):
+            return _FakeStream(_FakeResp())
+
+    import httpx
+
+    monkeypatch.setattr(httpx, "AsyncClient", _FakeClient)
+
+    key = await ch.upload_media(
+        MediaSource(kind="url", url="https://cdn.ok.test/x.png"),
+        kind="image",
+    )
+
+    assert key == "img_url"
diff --git a/lark_channel/channel/tests/test_user_agent.py b/lark_channel/channel/tests/test_user_agent.py
new file mode 100644
index 0000000..91f5a18
--- /dev/null
+++ b/lark_channel/channel/tests/test_user_agent.py
@@ -0,0 +1,135 @@
+"""User-Agent construction + ``channel`` tag propagation.
+
+Mirrors node-sdk ``utils/__tests__/user-agent.ts`` plus integration coverage
+for FeishuChannel passing ``extra_ua_tags=["channel"]`` into the underlying
+HTTP and WebSocket clients.
+"""
+
+import re
+
+from lark_channel.channel import FeishuChannel
+from lark_channel.client import Client
+from lark_channel.core.const import PROJECT, USER_AGENT, VERSION
+from lark_channel.core.http.transport import _build_header
+from lark_channel.core.model.base_request import BaseRequest
+from lark_channel.core.model.config import Config
+from lark_channel.core.model.request_option import RequestOption
+from lark_channel.core.utils.user_agent import build_user_agent
+from lark_channel.ws.client import Client as WSClient
+
+
+_BASE = f"{PROJECT}/v{VERSION}"
+
+
+# ---------------------------------------------------------------------------
+# build_user_agent — port of node-sdk tests
+# ---------------------------------------------------------------------------
+
+
+def test_base_ua_when_no_source_or_tags():
+    assert build_user_agent() == _BASE
+
+
+def test_source_appended_as_product_token():
+    assert build_user_agent("cursor-bot") == f"{_BASE} source/cursor-bot"
+
+
+def test_source_with_invalid_chars_is_sanitized():
+    # all-invalid source still produces an empty token → drop the segment
+    assert build_user_agent("机器人") == f"{_BASE} source/___"
+
+
+def test_extra_tags_appended_as_bare_tokens_after_source():
+    ua = build_user_agent("cursor-bot", extra_tags=["channel"])
+    assert re.match(rf"^{re.escape(_BASE)} source/cursor-bot channel$", ua)
+
+
+def test_extra_tags_appended_even_without_source():
+    ua = build_user_agent(extra_tags=["channel"])
+    assert ua == f"{_BASE} channel"
+
+
+def test_multiple_extra_tags_appended_in_order():
+    ua = build_user_agent("x", extra_tags=["channel", "beta"])
+    assert "source/x channel beta" in ua
+
+
+def test_extra_tags_are_sanitized():
+    ua = build_user_agent(extra_tags=["has space"])
+    assert "has_space" in ua
+
+
+def test_empty_extra_tag_is_dropped():
+    ua = build_user_agent("x", extra_tags=[""])
+    assert ua == f"{_BASE} source/x"
+
+
+# ---------------------------------------------------------------------------
+# transport._build_header — UA wired through Config
+# ---------------------------------------------------------------------------
+
+
+def _new_request() -> BaseRequest:
+    req = BaseRequest()
+    req.headers = {}
+    req.token_types = set()
+    return req
+
+
+def test_transport_ua_contains_source_and_extra_tags():
+    cfg = Config()
+    cfg.source = "cursor-bot"
+    cfg.extra_ua_tags = ["channel"]
+    headers = _build_header(_new_request(), RequestOption(), cfg)
+    assert headers[USER_AGENT] == f"{_BASE} source/cursor-bot channel"
+
+
+def test_transport_ua_falls_back_to_base_when_conf_none():
+    headers = _build_header(_new_request(), RequestOption(), None)
+    assert headers[USER_AGENT] == _BASE
+
+
+# ---------------------------------------------------------------------------
+# FeishuChannel propagates ``channel`` tag into both clients
+# ---------------------------------------------------------------------------
+
+
+def test_channel_sets_extra_ua_tags_on_underlying_client():
+    ch = FeishuChannel(app_id="cli_test", app_secret="secret")
+    try:
+        assert ch.client._config is not None
+        assert ch.client._config.extra_ua_tags == ["channel"]
+    finally:
+        # Channel construction starts no background loops; nothing to tear
+        # down beyond letting the object go out of scope.
+        pass
+
+
+def test_ws_client_ua_includes_channel_tag():
+    ws = WSClient(
+        app_id="cli_test",
+        app_secret="secret",
+        extra_ua_tags=["channel"],
+    )
+    assert ws._user_agent == f"{_BASE} channel"
+
+
+def test_ws_client_default_ua_has_no_extra_tag():
+    ws = WSClient(app_id="cli_test", app_secret="secret")
+    assert ws._user_agent == _BASE
+
+
+# ---------------------------------------------------------------------------
+# ClientBuilder.source() exposes the public knob
+# ---------------------------------------------------------------------------
+
+
+def test_client_builder_source_propagates_to_config():
+    client = (
+        Client.builder()
+        .app_id("cli_test")
+        .app_secret("secret")
+        .source("my-bot")
+        .build()
+    )
+    assert client._config.source == "my-bot"
diff --git a/lark_channel/channel/types.py b/lark_channel/channel/types.py
new file mode 100644
index 0000000..912b22d
--- /dev/null
+++ b/lark_channel/channel/types.py
@@ -0,0 +1,814 @@
+"""Unified data types exposed to channel handlers.
+
+Design goal: a single `MessageContent` discriminated union covers all 19 Lark
+message types so that handlers can `if content.kind == 'text': ...` without
+having to know the original wire format.
+"""
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Literal, Optional, Union
+
+from .errors import SendError
+
+# ----------------------------------------------------------------------------
+# Conversation / Identity
+# ----------------------------------------------------------------------------
+
+ChatType = Literal["p2p", "group", "topic", "unknown"]
+
+
+@dataclass
+class Conversation:
+    chat_id: str
+    chat_type: ChatType = "unknown"
+    thread_id: Optional[str] = None
+
+
+@dataclass
+class Identity:
+    open_id: str
+    union_id: Optional[str] = None
+    user_id: Optional[str] = None
+    display_name: Optional[str] = None
+    is_bot: bool = False
+
+
+@dataclass
+class Mention:
+    """A resolved @-mention occurrence in inbound message text.
+
+    Each mention pairs the placeholder ``key`` (e.g. ``@_user_1``) with the
+    identity it resolves to.
+    """
+
+    key: str  # the placeholder key, e.g. @_user_1
+    open_id: Optional[str] = None
+    user_id: Optional[str] = None
+    name: Optional[str] = None
+    is_bot: bool = False
+    union_id: Optional[str] = None
+    tenant_key: Optional[str] = None
+
+
+# ----------------------------------------------------------------------------
+# Media reference
+# ----------------------------------------------------------------------------
+
+
+@dataclass
+class MediaRef:
+    """Points to a media object already stored inside Lark (file_key or image_key)."""
+
+    key: str
+    media_type: Literal["image", "file", "audio", "video"]
+    file_name: Optional[str] = None
+    mime_type: Optional[str] = None
+    size: Optional[int] = None
+    duration_ms: Optional[int] = None
+
+
+ResourceType = Literal["image", "file", "audio", "video", "sticker"]
+
+
+@dataclass
+class ResourceDescriptor:
+    """Media descriptor exposed alongside the flattened ``content_text``.
+
+    Each descriptor carries everything needed to download the resource via
+    ``channel.download_resource(file_key, type)``, independent of which
+    ``MessageContent`` variant originally carried it.
+    """
+
+    type: ResourceType
+    file_key: str
+    file_name: Optional[str] = None
+    duration_ms: Optional[int] = None
+    cover_image_key: Optional[str] = None
+
+
+@dataclass
+class CachedResource:
+    decision: Literal["cached", "rejected", "skipped"]
+    reason: Optional[str] = None
+    path: Optional[Any] = None
+    sha256: Optional[str] = None
+    mime_type: Optional[str] = None
+    size: Optional[int] = None
+    source_message_id: Optional[str] = None
+    source_file_key: Optional[str] = None
+    resource_type: Optional[str] = None
+
+
+@dataclass
+class CommentTarget:
+    file_token: str
+    file_type: str
+    supported: bool
+    reason: Optional[str] = None
+    raw: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class CommentContext:
+    target: CommentTarget
+    comment_id: str
+    question: str
+    quote: str
+    is_whole: bool
+    target_reply_id: Optional[str]
+    raw: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class ConnectionSnapshot:
+    state: str
+    ready: bool
+    reconnect_attempts: int = 0
+    last_connected_at: Optional[float] = None
+    last_disconnected_at: Optional[float] = None
+    last_error_at: Optional[float] = None
+    last_error: Optional[str] = None
+
+
+# ----------------------------------------------------------------------------
+# MessageContent union — 19 kinds + unknown
+# ----------------------------------------------------------------------------
+#
+# Content dataclasses are **pipeline-populated**, not directly user-constructed.
+# The inbound :class:`InboundPipeline` reads a Feishu message payload, selects
+# the right ``*Content`` class based on the wire ``message_type``, and fills
+# in the fields. Test fixtures may instantiate them directly; application
+# code generally shouldn't.
+#
+# The ``kind`` field on each class is a :class:`typing.Literal` discriminator
+# that matches Feishu's wire-protocol ``message_type`` string. It has a
+# default because Python 3.8 ``@dataclass`` doesn't support ``kw_only``
+# required fields after defaulted ones (``raw`` on the base); treat ``kind``
+# as non-user-settable.
+# ----------------------------------------------------------------------------
+
+
+@dataclass
+class _BaseContent:
+    raw: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class TextContent(_BaseContent):
+    kind: Literal["text"] = "text"
+    text: str = ""
+
+
+@dataclass
+class PostContent(_BaseContent):
+    kind: Literal["post"] = "post"
+    title: str = ""
+    text: str = ""  # plain-text rendering (best-effort)
+    post: Dict[str, Any] = field(default_factory=dict)  # raw post AST by locale
+
+
+@dataclass
+class ImageContent(_BaseContent):
+    kind: Literal["image"] = "image"
+    image_key: str = ""
+
+
+@dataclass
+class FileContent(_BaseContent):
+    kind: Literal["file"] = "file"
+    file_key: str = ""
+    file_name: Optional[str] = None
+
+
+@dataclass
+class AudioContent(_BaseContent):
+    kind: Literal["audio"] = "audio"
+    file_key: str = ""
+    duration_ms: Optional[int] = None
+
+
+@dataclass
+class MediaContent(_BaseContent):
+    kind: Literal["media"] = "media"
+    file_key: str = ""
+    image_key: Optional[str] = None  # cover
+    duration_ms: Optional[int] = None
+    file_name: Optional[str] = None
+
+
+@dataclass
+class StickerContent(_BaseContent):
+    kind: Literal["sticker"] = "sticker"
+    file_key: str = ""
+
+
+@dataclass
+class InteractiveContent(_BaseContent):
+    kind: Literal["interactive"] = "interactive"
+    card: Dict[str, Any] = field(default_factory=dict)  # unified v1/v2 JSON
+    card_version: Literal["v1", "v2", "unknown"] = "unknown"
+
+
+@dataclass
+class ShareChatContent(_BaseContent):
+    kind: Literal["share_chat"] = "share_chat"
+    chat_id: str = ""
+
+
+@dataclass
+class ShareUserContent(_BaseContent):
+    kind: Literal["share_user"] = "share_user"
+    user_id: str = ""
+
+
+@dataclass
+class SystemContent(_BaseContent):
+    kind: Literal["system"] = "system"
+    template: str = ""
+    from_user: List[Dict[str, Any]] = field(default_factory=list)
+    to_chatters: List[Dict[str, Any]] = field(default_factory=list)
+
+
+@dataclass
+class LocationContent(_BaseContent):
+    kind: Literal["location"] = "location"
+    name: str = ""
+    longitude: Optional[float] = None
+    latitude: Optional[float] = None
+
+
+@dataclass
+class FolderContent(_BaseContent):
+    """Message carrying a shared Drive folder reference.
+
+    ``file_key`` is the primary identifier on the wire (matches node's
+    ``FolderContent.file_key``); without it the converter falls back to a
+    ``[folder]`` placeholder.
+    """
+
+    kind: Literal["folder"] = "folder"
+    file_key: str = ""
+    file_name: str = ""
+    file_size: Optional[int] = None
+
+
+@dataclass
+class RedPacketContent(_BaseContent):
+    """Red-packet message.
+
+    ``RedPacketContent`` is the preferred Python name; ``HongbaoContent`` is
+    kept as a back-compat alias because the Feishu wire-protocol uses the
+    Pinyin form ``hongbao`` in its message-type discriminator.
+    """
+
+    kind: Literal["hongbao"] = "hongbao"
+    text: str = ""
+    amount: Optional[int] = None
+
+
+# Back-compat alias for the (ugly) name that mirrors Feishu's on-wire
+# ``hongbao`` message-type discriminator. New code should prefer
+# ``RedPacketContent``.
+HongbaoContent = RedPacketContent
+
+
+@dataclass
+class GeneralCalendarContent(_BaseContent):
+    """Generic calendar event share."""
+
+    kind: Literal["general_calendar"] = "general_calendar"
+    summary: str = ""
+    start_time: Optional[int] = None
+    end_time: Optional[int] = None
+
+
+@dataclass
+class ShareCalendarEventContent(_BaseContent):
+    """A specific calendar event share (richer than `calendar`)."""
+
+    kind: Literal["share_calendar_event"] = "share_calendar_event"
+    summary: str = ""
+    organizer: str = ""
+    start_time: Optional[int] = None
+    end_time: Optional[int] = None
+
+
+@dataclass
+class VideoChatContent(_BaseContent):
+    kind: Literal["video_chat"] = "video_chat"
+    topic: str = ""
+    start_time: Optional[int] = None
+
+
+@dataclass
+class CalendarContent(_BaseContent):
+    kind: Literal["calendar"] = "calendar"
+    summary: str = ""
+    start_time: Optional[int] = None
+    end_time: Optional[int] = None
+
+
+@dataclass
+class VoteContent(_BaseContent):
+    kind: Literal["vote"] = "vote"
+    topic: str = ""
+    options: List[str] = field(default_factory=list)
+
+
+@dataclass
+class TodoContent(_BaseContent):
+    """Todo message.
+
+    On the wire the ``summary`` field is a nested ``{title, content}`` object
+    where ``content`` is a post-AST (paragraphs of text/link elements). The
+    parser extracts plain ``title`` + ``body`` eagerly so the converter can
+    format a rich ``<todo>`` block without re-walking the AST.
+    """
+
+    kind: Literal["todo"] = "todo"
+    title: str = ""
+    body: str = ""
+    due_time: Optional[int] = None
+
+
+@dataclass
+class MergeForwardItem:
+    """A single child message inside a merge_forward payload."""
+
+    message_id: str
+    sender_open_id: Optional[str] = None
+    sender_name: Optional[str] = None
+    create_time: Optional[int] = None
+    content: Optional["MessageContent"] = None
+    raw: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class MergeForwardContent(_BaseContent):
+    kind: Literal["merge_forward"] = "merge_forward"
+    loading: bool = False
+    items: List[MergeForwardItem] = field(default_factory=list)
+    truncated: bool = False
+    error: Optional[str] = None
+
+
+@dataclass
+class UnknownContent(_BaseContent):
+    kind: Literal["unknown"] = "unknown"
+    message_type: str = ""
+
+
+MessageContent = Union[
+    TextContent,
+    PostContent,
+    ImageContent,
+    FileContent,
+    AudioContent,
+    MediaContent,
+    StickerContent,
+    InteractiveContent,
+    ShareChatContent,
+    ShareUserContent,
+    SystemContent,
+    LocationContent,
+    FolderContent,
+    HongbaoContent,
+    GeneralCalendarContent,
+    ShareCalendarEventContent,
+    VideoChatContent,
+    CalendarContent,
+    VoteContent,
+    TodoContent,
+    MergeForwardContent,
+    UnknownContent,
+]
+
+
+# ----------------------------------------------------------------------------
+# Reply
+# ----------------------------------------------------------------------------
+
+
+@dataclass
+class ReplyRef:
+    message_id: str
+    text: Optional[str] = None
+    sender_id: Optional[str] = None
+
+
+# ----------------------------------------------------------------------------
+# InboundMessage
+# ----------------------------------------------------------------------------
+
+
+@dataclass
+class InboundMessage:
+    """Inbound-normalized message.
+
+    Main views of the content:
+    - `content`: discriminated-union (`TextContent` / `ImageContent` / ...)
+      — Pythonic, type-checkable.
+    - `content_text`: flat string rendering (Markdown for text/post, XML-like
+      placeholders for media, merge_forward trees) — convenient for text-only
+      pipelines.
+    - `resources`: parallel list of media descriptors for download/routing.
+    - `mentioned_bot`: convenience flag set by normalization/batching callers
+      when any mention resolves to the current bot's open_id.
+    """
+
+    id: str
+    create_time: int
+    conversation: Conversation
+    sender: Identity
+    mentions: List[Mention] = field(default_factory=list)
+    mentioned_all: bool = False
+    reply: Optional[ReplyRef] = None
+    content: MessageContent = field(default_factory=UnknownContent)
+    raw: Dict[str, Any] = field(default_factory=dict)
+    # Flat-text / resource views of `content`, populated by the pipeline
+    content_text: str = ""
+    resources: List[ResourceDescriptor] = field(default_factory=list)
+    mentioned_bot: bool = False
+    raw_content_type: str = ""
+    batched_sources: Optional[List["InboundMessage"]] = None
+    chat_mode: Optional[str] = None
+    safe_content_text: str = ""
+
+    @property
+    def message_id(self) -> str:
+        """Alias for ``id`` — the message's stable identifier."""
+        return self.id
+
+    @property
+    def chat_id(self) -> str:
+        return self.conversation.chat_id
+
+    @property
+    def chat_type(self) -> str:
+        return self.conversation.chat_type
+
+    @property
+    def sender_id(self) -> str:
+        return self.sender.open_id
+
+    @property
+    def sender_name(self) -> Optional[str]:
+        return self.sender.display_name
+
+    @property
+    def reply_to_message_id(self) -> Optional[str]:
+        return self.reply.message_id if self.reply else None
+
+
+# ----------------------------------------------------------------------------
+# Outbound messages
+# ----------------------------------------------------------------------------
+
+
+@dataclass
+class _OutBase:
+    pass
+
+
+@dataclass
+class OutboundText(_OutBase):
+    kind: Literal["text"] = "text"
+    text: str = ""
+    mentions: List[Identity] = field(default_factory=list)
+
+
+@dataclass
+class OutboundPost(_OutBase):
+    kind: Literal["post"] = "post"
+    markdown: Optional[str] = None
+    post: Optional[Dict[str, Any]] = None
+    title: Optional[str] = None
+    mentions: List[Identity] = field(default_factory=list)
+
+
+@dataclass
+class OutboundCard(_OutBase):
+    kind: Literal["card"] = "card"
+    card: Dict[str, Any] = field(default_factory=dict)
+    card_id: Optional[str] = None
+
+
+MediaSourceKind = Literal["url", "file", "buffer", "key"]
+
+
+@dataclass
+class MediaSource:
+    kind: MediaSourceKind
+    url: Optional[str] = None
+    path: Optional[str] = None
+    buffer: Optional[bytes] = None
+    key: Optional[str] = None
+
+
+@dataclass
+class OutboundImage(_OutBase):
+    kind: Literal["image"] = "image"
+    source: Optional[MediaSource] = None
+    caption: Optional[str] = None
+
+
+@dataclass
+class OutboundFile(_OutBase):
+    kind: Literal["file"] = "file"
+    source: Optional[MediaSource] = None
+    file_name: Optional[str] = None
+    caption: Optional[str] = None
+
+
+@dataclass
+class OutboundAudio(_OutBase):
+    kind: Literal["audio"] = "audio"
+    source: Optional[MediaSource] = None
+    caption: Optional[str] = None
+
+
+@dataclass
+class OutboundVideo(_OutBase):
+    kind: Literal["video"] = "video"
+    source: Optional[MediaSource] = None
+    caption: Optional[str] = None
+
+
+@dataclass
+class OutboundShareChat(_OutBase):
+    """Send a group chat "business card" referencing ``chat_id``.
+
+    Feishu wire form: ``msg_type="share_chat"`` / ``content={"chat_id": "..."}``.
+    """
+
+    kind: Literal["share_chat"] = "share_chat"
+    chat_id: str = ""
+
+
+@dataclass
+class OutboundShareUser(_OutBase):
+    """Send a personal card referencing a user's ``open_id`` (or union_id).
+
+    Feishu wire form: ``msg_type="share_user"`` / ``content={"user_id": "..."}``.
+    """
+
+    kind: Literal["share_user"] = "share_user"
+    user_id: str = ""
+
+
+@dataclass
+class OutboundSticker(_OutBase):
+    """Send a sticker by its ``file_key``.
+
+    Feishu wire form: ``msg_type="sticker"`` / ``content={"file_key": "..."}``.
+    """
+
+    kind: Literal["sticker"] = "sticker"
+    file_key: str = ""
+
+
+OutboundMessage = Union[
+    OutboundText,
+    OutboundPost,
+    OutboundCard,
+    OutboundImage,
+    OutboundFile,
+    OutboundAudio,
+    OutboundVideo,
+    OutboundShareChat,
+    OutboundShareUser,
+    OutboundSticker,
+]
+
+
+# ----------------------------------------------------------------------------
+# Send result
+# ----------------------------------------------------------------------------
+
+
+@dataclass
+class SendResult:
+    """The outcome of a single :meth:`FeishuChannel.send` or ``stream`` call.
+
+    For messages that fit in one wire payload, only ``message_id`` is set.
+    For messages that get split across multiple wire payloads (long
+    markdown, long post — see :mod:`.outbound.sender._materialize`),
+    ``chunk_ids`` lists **every** chunk's message_id in order, and
+    ``message_id`` holds the first chunk for convenience / back-compat.
+    ``chunk_ids`` is ``None`` when there was only one chunk.
+    """
+
+    success: bool
+    message_id: Optional[str] = None
+    error: Optional[SendError] = None
+    raw: Optional[Dict[str, Any]] = None
+    chunk_ids: Optional[List[str]] = None
+
+    @classmethod
+    def ok(
+        cls,
+        message_id: Optional[str] = None,
+        raw: Optional[Dict[str, Any]] = None,
+        chunk_ids: Optional[List[str]] = None,
+    ) -> "SendResult":
+        return cls(
+            success=True, message_id=message_id, raw=raw, chunk_ids=chunk_ids,
+        )
+
+    @classmethod
+    def fail(cls, error: SendError, raw: Optional[Dict[str, Any]] = None) -> "SendResult":
+        return cls(success=False, error=error, raw=raw)
+
+
+# ----------------------------------------------------------------------------
+# Card payload
+# ----------------------------------------------------------------------------
+
+
+@dataclass
+class CardPayload:
+    """A finalised CardKit JSON object ready for the Lark API."""
+
+    data: Dict[str, Any]
+    version: Literal["v1", "v2"] = "v2"
+
+
+# ----------------------------------------------------------------------------
+# User Access Token
+# ----------------------------------------------------------------------------
+
+
+@dataclass
+class UserAccessToken:
+    """A resolved user access token (UAT) for a specific end-user.
+
+    Holds both the short-lived access token and the refresh token (when
+    granted), along with the scopes, user identity, and raw vendor response
+    for diagnostics.
+    """
+
+    access_token: str
+    refresh_token: Optional[str] = None
+    expires_at: Optional[float] = None  # unix seconds
+    refresh_expires_at: Optional[float] = None
+    scopes: List[str] = field(default_factory=list)
+    open_id: Optional[str] = None
+    raw: Dict[str, Any] = field(default_factory=dict)
+
+
+# Back-compat alias — existing code and tests import ``UAT`` directly. Kept
+# for one release to ease migration; prefer ``UserAccessToken`` in new code.
+UAT = UserAccessToken
+
+
+# ----------------------------------------------------------------------------
+# Send options / routing
+# ----------------------------------------------------------------------------
+
+ReceiveIdType = Literal["open_id", "chat_id", "user_id", "union_id", "email"]
+ReplyTargetGoneBehavior = Literal["fresh", "fail"]
+
+
+@dataclass
+class SendOpts:
+    reply_to: Optional[str] = None  # message_id — forces reply mode
+    reply_in_thread: Optional[bool] = None
+    receive_id: Optional[str] = None  # explicit target; overrides auto-routing
+    receive_id_type: Optional[ReceiveIdType] = None
+    uuid: Optional[str] = None
+    reply_target_gone: ReplyTargetGoneBehavior = "fresh"
+
+
+@dataclass
+class Target:
+    """Receiver spec for out-of-band sends (not tied to an inbound ctx)."""
+
+    id: str
+    id_type: ReceiveIdType = "chat_id"
+
+
+# ---------------------------------------------------------------------------
+# Event payload dataclasses passed to `channel.on(...)` handlers when using
+# the FeishuChannel facade.
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class EventOperator:
+    """Who performed an action: ``open_id`` plus optional ``user_id`` / ``name``."""
+
+    open_id: str = ""
+    user_id: Optional[str] = None
+    name: Optional[str] = None
+
+
+@dataclass
+class CardActionPayload:
+    """Inner ``action`` field of a ``CardActionEvent``.
+
+    ``value`` is the form/button data; ``tag`` identifies which element fired;
+    ``name`` / ``option`` carry element-specific metadata.
+    """
+
+    value: Any = None
+    tag: str = ""
+    name: Optional[str] = None
+    option: Optional[str] = None
+    form_value: Any = field(default=None, compare=False, repr=False)
+    input_value: Any = field(default=None, compare=False, repr=False)
+    options: Any = field(default=None, compare=False, repr=False)
+    checked: Any = field(default=None, compare=False, repr=False)
+
+
+@dataclass
+class CardActionEvent:
+    """Emitted to ``channel.on("cardAction", ...)`` handlers.
+
+    Carries the ``message_id`` and ``chat_id`` of the source card plus the
+    resolved ``operator`` and ``action`` payload.
+    """
+
+    message_id: str
+    chat_id: str
+    operator: EventOperator
+    action: CardActionPayload
+    raw: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class ReactionEvent:
+    """Emitted to `channel.on("reaction", ...)` handlers."""
+
+    message_id: str
+    operator: EventOperator
+    emoji_type: str
+    action: str  # 'added' | 'removed'
+    chat_id: Optional[str] = None
+    chat_type: Optional[ChatType] = None
+    action_time: Optional[int] = None
+    raw: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class BotAddedEvent:
+    """Emitted to `channel.on("botAdded", ...)` when the bot joins a chat."""
+
+    chat_id: str
+    operator: EventOperator
+    chat_name: Optional[str] = None
+    external: Optional[bool] = None
+    raw: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class BotLeaveEvent:
+    """Emitted to ``channel.on("botLeave", ...)`` when the bot is removed from a chat."""
+
+    chat_id: str
+    operator: EventOperator
+    raw: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class MessageReadEvent:
+    """Emitted to `channel.on("messageRead", ...)` for read-receipt events."""
+
+    reader: EventOperator
+    message_ids: List[str] = field(default_factory=list)
+    raw: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class ChatInfo:
+    """Returned by ``channel.get_chat_info(chat_id)``."""
+
+    chat_id: str
+    name: Optional[str] = None
+    description: Optional[str] = None
+    chat_type: ChatType = "unknown"
+    owner_id: Optional[str] = None
+    member_count: Optional[int] = None
+    raw: Dict[str, Any] = field(default_factory=dict)
+
+    @property
+    def chat_mode(self) -> Optional[str]:
+        value = self.raw.get("chat_mode")
+        return str(value) if value else None
+
+
+@dataclass
+class QuotedContext:
+    message_id: str
+    text: str = ""
+    sender_id: Optional[str] = None
+    create_time: Optional[int] = None
+    content_type: Optional[str] = None
+    raw: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class QuoteResolution:
+    message_id: str
+    parent_message_id: Optional[str]
+    decision: Literal["resolved", "no_parent", "in_batch", "topic_root", "fetch_failed"]
+    context: Optional[QuotedContext] = None
diff --git a/lark_channel/client.py b/lark_channel/client.py
new file mode 100644
index 0000000..0eb667d
--- /dev/null
+++ b/lark_channel/client.py
@@ -0,0 +1,161 @@
+import urllib.parse
+from typing import Optional
+
+from .api.cardkit.service import CardkitService
+from .api.contact.service import ContactService
+from .api.im.service import ImService
+from .core import JSON, APPLICATION_JSON, CONTENT_TYPE, UTF_8, logger
+from .core.cache import ICache
+from .core.enum import AppType, LogLevel
+from .core.http import Transport
+from .core.model import BaseRequest, BaseResponse, Config, RequestOption
+from .core.token import TokenManager, verify
+from .core.utils.files import Files
+
+
+def _validate_domain(domain: str) -> None:
+    """Reject domains that could redirect credential-bearing API traffic."""
+    if not isinstance(domain, str) or not domain:
+        raise ValueError("domain must be a non-empty https URL")
+    parsed = urllib.parse.urlsplit(domain)
+    if parsed.scheme == "http":
+        host = (parsed.hostname or "").lower()
+        if host not in ("127.0.0.1", "localhost", "::1"):
+            raise ValueError(f"domain must use https scheme (got {domain!r})")
+    elif parsed.scheme != "https":
+        raise ValueError(f"domain must use https scheme (got {domain!r})")
+    if not parsed.netloc:
+        raise ValueError(f"domain missing host (got {domain!r})")
+    if "@" in parsed.netloc:
+        raise ValueError(f"domain must not embed credentials (got {domain!r})")
+    if parsed.path or parsed.query or parsed.fragment:
+        raise ValueError(
+            "domain must be an origin (scheme + host[:port]) without "
+            f"path/query/fragment (got {domain!r})"
+        )
+
+
+class Client(object):
+    def __init__(self) -> None:
+        self._config: Optional[Config] = None
+        self.cardkit: Optional[CardkitService] = None
+        self.contact: Optional[ContactService] = None
+        self.im: Optional[ImService] = None
+
+    @staticmethod
+    def builder() -> "ClientBuilder":
+        return ClientBuilder()
+
+    @property
+    def config(self) -> Optional[Config]:
+        return self._config
+
+    def request(
+        self, request: BaseRequest, option: Optional[RequestOption] = None
+    ) -> BaseResponse:
+        if option is None:
+            option = RequestOption()
+
+        verify(self._config, request, option)
+        raw_resp = Transport.execute(self._config, request, option)
+
+        resp = BaseResponse()
+        content_type = raw_resp.headers.get(CONTENT_TYPE)
+        if content_type is not None and content_type.startswith(APPLICATION_JSON):
+            resp = JSON.unmarshal(str(raw_resp.content, UTF_8), BaseResponse)
+        elif 200 <= raw_resp.status_code < 300:
+            resp.code = 0
+        resp.raw = raw_resp
+        return resp
+
+    async def arequest(
+        self, request: BaseRequest, option: Optional[RequestOption] = None
+    ) -> BaseResponse:
+        if option is None:
+            option = RequestOption()
+
+        verify(self._config, request, option)
+        request.files = Files.extract_files(request.body)
+        raw_resp = await Transport.aexecute(self._config, request, option)
+
+        resp = BaseResponse()
+        content_type = raw_resp.headers.get(CONTENT_TYPE)
+        if content_type is not None and content_type.startswith(APPLICATION_JSON):
+            resp = JSON.unmarshal(str(raw_resp.content, UTF_8), BaseResponse)
+        elif 200 <= raw_resp.status_code < 300:
+            resp.code = 0
+        resp.raw = raw_resp
+        return resp
+
+
+class ClientBuilder(object):
+    def __init__(self) -> None:
+        self._config = Config()
+
+    def app_id(self, app_id: str) -> "ClientBuilder":
+        self._config.app_id = app_id
+        return self
+
+    def app_secret(self, app_secret: str) -> "ClientBuilder":
+        self._config.app_secret = app_secret
+        return self
+
+    def domain(self, domain: str) -> "ClientBuilder":
+        _validate_domain(domain)
+        self._config.domain = domain
+        return self
+
+    def timeout(self, timeout: float) -> "ClientBuilder":
+        self._config.timeout = timeout
+        return self
+
+    def proxy_url(self, proxy_url: Optional[str]) -> "ClientBuilder":
+        self._config.proxy_url = proxy_url
+        return self
+
+    def trust_env_proxy(self, trust_env_proxy: Optional[bool]) -> "ClientBuilder":
+        self._config.trust_env_proxy = trust_env_proxy
+        return self
+
+    def app_type(self, app_type: AppType) -> "ClientBuilder":
+        self._config.app_type = app_type
+        return self
+
+    def app_ticket(self, app_ticket: str) -> "ClientBuilder":
+        self._config.app_ticket = app_ticket
+        return self
+
+    def enable_set_token(self, enable_set_token: bool) -> "ClientBuilder":
+        self._config.enable_set_token = enable_set_token
+        return self
+
+    def cache(self, cache: ICache) -> "ClientBuilder":
+        self._config.cache = cache
+        return self
+
+    def log_level(self, log_level: LogLevel) -> "ClientBuilder":
+        self._config.log_level = log_level
+        return self
+
+    def source(self, source: str) -> "ClientBuilder":
+        self._config.source = source
+        return self
+
+    def build(self) -> Client:
+        client = Client()
+        client._config = self._config
+
+        self._init_cache()
+        self._init_logger()
+
+        client.cardkit = CardkitService(self._config)
+        client.contact = ContactService(self._config)
+        client.im = ImService(self._config)
+        return client
+
+    def _init_cache(self) -> None:
+        if self._config.cache is not None:
+            TokenManager.cache = self._config.cache
+
+    def _init_logger(self) -> None:
+        logger.setLevel(int(self._config.log_level.value))
diff --git a/lark_channel/core/__init__.py b/lark_channel/core/__init__.py
new file mode 100644
index 0000000..2da1ab6
--- /dev/null
+++ b/lark_channel/core/__init__.py
@@ -0,0 +1,9 @@
+from .cache import ICache
+from .const import *
+from .enum import *
+from .env_var import *
+from .json import JSON
+from .log import logger
+from .model import RequestOption, BaseRequest, BaseResponse, RawRequest, RawResponse
+from .type import *
+from .utils import *
diff --git a/lark_channel/core/cache/__init__.py b/lark_channel/core/cache/__init__.py
new file mode 100644
index 0000000..b128532
--- /dev/null
+++ b/lark_channel/core/cache/__init__.py
@@ -0,0 +1,3 @@
+from .cache import *
+from .expiring_cache import *
+from .local_cache import *
diff --git a/lark_channel/core/cache/cache.py b/lark_channel/core/cache/cache.py
new file mode 100644
index 0000000..1746739
--- /dev/null
+++ b/lark_channel/core/cache/cache.py
@@ -0,0 +1,12 @@
+from abc import ABC, abstractmethod
+
+
+class ICache(ABC):
+    @abstractmethod
+    def get(self, key: str) -> str:
+        pass
+
+    # expire: expiration time, Unix timestamp (seconds)
+    @abstractmethod
+    def set(self, key: str, value: str, expire: int):
+        pass
diff --git a/lark_channel/core/cache/expiring_cache.py b/lark_channel/core/cache/expiring_cache.py
new file mode 100644
index 0000000..653a7cc
--- /dev/null
+++ b/lark_channel/core/cache/expiring_cache.py
@@ -0,0 +1,47 @@
+import asyncio
+import time
+from typing import Dict, Tuple, Any
+
+
+class ExpiringCache(object):
+
+    def __init__(self, clear_interval=60):
+        self._cache: Dict[str, Tuple[Any, float]] = {}
+        self._clear_interval: int = clear_interval
+
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+        self._cron = loop.create_task(self._start_clear_cron())
+
+    def __del__(self):
+        self._cron.cancel()
+
+    def get(self, key: str) -> Any:
+        elem = self._cache.get(key)
+        if not elem:
+            return None
+        value, expire = elem
+        if expire < time.time():
+            del self._cache[key]
+            return None
+
+        return value
+
+    # ttl: time to live, in seconds
+    def set(self, key: str, value: Any, ttl: int):
+        expire = time.time() + ttl
+        self._cache[key] = (value, expire)
+
+    def _clear(self):
+        now = time.time()
+        expired_keys = [key for key, (value, expire) in self._cache.items() if expire < now]
+        for key in expired_keys:
+            del self._cache[key]
+
+    async def _start_clear_cron(self):
+        while True:
+            await asyncio.sleep(self._clear_interval)
+            self._clear()
diff --git a/lark_channel/core/cache/local_cache.py b/lark_channel/core/cache/local_cache.py
new file mode 100644
index 0000000..2a5af94
--- /dev/null
+++ b/lark_channel/core/cache/local_cache.py
@@ -0,0 +1,34 @@
+import time
+from typing import Dict, Optional
+
+from lark_channel.core.cache import ICache
+
+
+class LocalCache(ICache):
+
+    def __init__(self):
+        self.cache: Dict[str, LocalCache.ValueWrap] = {}
+
+    def get(self, key: str) -> Optional[str]:
+        wrap: LocalCache.ValueWrap = self.cache.get(key)
+        if wrap is None:
+            return None
+        if wrap.expire < time.time():
+            del self.cache[key]
+            return None
+
+        return wrap.value
+
+    def set(self, key: str, value: str, expire: int) -> None:
+        self.cache[key] = LocalCache.ValueWrap(value, expire)
+
+    @staticmethod
+    def instance() -> "LocalCache":
+        if not hasattr(LocalCache, "__instance"):
+            LocalCache.__instance = LocalCache()
+        return LocalCache.__instance
+
+    class ValueWrap(object):
+        def __init__(self, value: str, expire: int):
+            self.value = value
+            self.expire = expire
diff --git a/lark_channel/core/const.py b/lark_channel/core/const.py
new file mode 100644
index 0000000..9fd0f34
--- /dev/null
+++ b/lark_channel/core/const.py
@@ -0,0 +1,26 @@
+# Info
+PROJECT = "channel-sdk-python"
+VERSION = "1.0.0"
+
+# Domain
+FEISHU_DOMAIN = "https://open.feishu.cn"
+LARK_DOMAIN = "https://open.larksuite.com"
+
+# Header
+USER_AGENT = "User-Agent"
+AUTHORIZATION = "Authorization"
+X_TT_LOGID = "X-Tt-Logid"
+X_REQUEST_ID = "X-Request-Id"
+CONTENT_TYPE = "Content-Type"
+Content_Disposition = "Content-Disposition"
+LARK_REQUEST_TIMESTAMP = "X-Lark-Request-Timestamp"
+LARK_REQUEST_NONCE = "X-Lark-Request-Nonce"
+LARK_REQUEST_SIGNATURE = "X-Lark-Signature"
+
+# Content-Type
+APPLICATION_JSON = "application/json"
+
+# Event
+URL_VERIFICATION = "url_verification"
+
+UTF_8 = "UTF-8"
diff --git a/lark_channel/core/construct.py b/lark_channel/core/construct.py
new file mode 100644
index 0000000..8c5a772
--- /dev/null
+++ b/lark_channel/core/construct.py
@@ -0,0 +1,76 @@
+from typing import *
+
+from .exception import UnmarshalException
+
+
+def init(obj: Any, d: Dict, types: Dict) -> None:
+    if d is None:
+        return
+    for k, v in d.items():
+        if not hasattr(obj, k):
+            continue
+        t: Type = types.get(k)
+        setattr(obj, k, parse(t, v, k))
+
+
+def parse(t: Type, v: Any, field: Any) -> Any:
+    if t is None or v is None:
+        return v
+
+    type_ = type_of(t)
+    if type_ is list or type_ is tuple or type_ is List:
+        if not isinstance(v, (list, tuple)):
+            raise UnmarshalException(t, type(v), field)
+        if hasattr(t, "__args__"):
+            sub_t = t.__args__[0]
+            return [parse(sub_t, i, field) for i in v]
+        return v
+
+    if type_ is dict or type_ is Dict:
+        if not isinstance(v, dict):
+            raise UnmarshalException(t, type(v), field)
+        if hasattr(t, "__args__"):
+            val_t = t.__args__[1]
+            return {k: parse(val_t, v[k], k) for k in v}
+        return v
+
+    if type_ is set or type_ is Set:
+        if not isinstance(v, set):
+            raise UnmarshalException(t, type(v), field)
+        if hasattr(t, "__args__"):
+            sub_t = t.__args__[0]
+            return {parse(sub_t, i, field) for i in v}
+        return v
+
+    if type_ is object:
+        if not isinstance(v, dict):
+            raise UnmarshalException(t, type(v), field)
+        return t(v)
+
+    return v
+
+
+def type_of(t: Type) -> Type:
+    if t is int or \
+            t is float or \
+            t is complex or \
+            t is str or \
+            t is bool or \
+            t is list or \
+            t is tuple or \
+            t is dict or \
+            t is set or \
+            t is Any:
+        return t
+
+    if hasattr(t, "_name"):
+        name = getattr(t, "_name")
+        if name == "Dict":
+            return Dict
+        if name == "List":
+            return List
+        if name == "Set":
+            return Set
+        return Any
+
+    return object
diff --git a/lark_channel/core/enum.py b/lark_channel/core/enum.py
new file mode 100644
index 0000000..10001a3
--- /dev/null
+++ b/lark_channel/core/enum.py
@@ -0,0 +1,32 @@
+from enum import Enum, auto
+
+
+class AppType(Enum):
+    SELF = auto()
+    ISV = auto()
+
+
+class HttpMethod(Enum):
+    GET = auto()
+    HEAD = auto()
+    POST = auto()
+    PUT = auto()
+    PATCH = auto()
+    DELETE = auto()
+    CONNECT = auto()
+    OPTIONS = auto()
+    TRACE = auto()
+
+
+class LogLevel(Enum):
+    DEBUG = 10
+    INFO = 20
+    WARNING = 30
+    ERROR = 40
+    CRITICAL = 50
+
+
+class AccessTokenType(Enum):
+    TENANT = auto()
+    APP = auto()
+    USER = auto()
diff --git a/lark_channel/core/env_var.py b/lark_channel/core/env_var.py
new file mode 100644
index 0000000..2be6ef4
--- /dev/null
+++ b/lark_channel/core/env_var.py
@@ -0,0 +1,6 @@
+import os
+
+APP_ID = os.getenv("APP_ID")
+APP_SECRET = os.getenv("APP_SECRET")
+ENCRYPT_KEY = os.getenv("ENCRYPT_KEY")
+VERIFICATION_TOKEN = os.getenv("VERIFICATION_TOKEN")
diff --git a/lark_channel/core/exception.py b/lark_channel/core/exception.py
new file mode 100644
index 0000000..a55aaaf
--- /dev/null
+++ b/lark_channel/core/exception.py
@@ -0,0 +1,43 @@
+class NoAuthorizationException(Exception):
+    def __init__(self, msg: str):
+        self.msg: str = msg
+
+
+class ObtainAccessTokenException(Exception):
+    def __init__(self, desc: str, code: int, msg: str):
+        self.desc = desc
+        self.code = code
+        self.msg = msg
+
+    def __str__(self):
+        return f"{self.desc}, code: {self.code}, msg: {self.msg}"
+
+
+class UnmarshalException(Exception):
+    def __init__(self, dst, src, field):
+        self.dst = dst
+        self.src = src
+        self.field = field
+
+    def __str__(self):
+        return f"expected {self.dst} but was {self.src} at field: {self.field}"
+
+
+class InvalidArgsException(Exception):
+    def __init__(self, msg: str):
+        self.msg: str = msg
+
+
+class AccessDeniedException(Exception):
+    def __init__(self, msg: str):
+        self.msg: str = msg
+
+
+class EventException(Exception):
+    def __init__(self, msg: str):
+        self.msg: str = msg
+
+
+class CardException(Exception):
+    def __init__(self, msg: str):
+        self.msg: str = msg
diff --git a/lark_channel/core/http/__init__.py b/lark_channel/core/http/__init__.py
new file mode 100644
index 0000000..38bbed6
--- /dev/null
+++ b/lark_channel/core/http/__init__.py
@@ -0,0 +1,2 @@
+from .handler import *
+from .transport import *
diff --git a/lark_channel/core/http/handler.py b/lark_channel/core/http/handler.py
new file mode 100644
index 0000000..3ec8c88
--- /dev/null
+++ b/lark_channel/core/http/handler.py
@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+
+from lark_channel.core.model import RawRequest, RawResponse
+
+
+class HttpHandler(ABC):
+    @abstractmethod
+    def do(self, req: RawRequest) -> RawResponse:
+        pass
diff --git a/lark_channel/core/http/transport.py b/lark_channel/core/http/transport.py
new file mode 100644
index 0000000..71cc7ed
--- /dev/null
+++ b/lark_channel/core/http/transport.py
@@ -0,0 +1,199 @@
+import json
+import logging
+import urllib.parse
+import inspect
+from typing import Dict, Optional
+
+import httpx
+import requests
+from requests_toolbelt import MultipartEncoder
+
+from lark_channel.core.const import *
+from lark_channel.core.json import JSON
+from lark_channel.core.log import (
+    logger,
+    redact_files_for_log,
+    redact_for_log,
+    redact_query_params_for_log,
+)
+from lark_channel.core.model import *
+from lark_channel.core.utils.user_agent import build_user_agent
+
+
+class Transport(object):
+
+    @staticmethod
+    def execute(conf: Config, req: BaseRequest, option: Optional[RequestOption] = None) -> RawResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Build the URL
+        url: str = _build_url(conf.domain, req.uri, req.paths)
+
+        # Assemble the headers
+        headers: Dict[str, str] = _build_header(req, option, conf)
+
+        data = req.body
+        if data is not None and not isinstance(data, MultipartEncoder):
+            data = JSON.marshal(req.body).encode(UTF_8)
+
+        request, proxy_kwargs = _sync_requester(conf)
+        response = request(
+            str(req.http_method.name),
+            url,
+            headers=req.headers,
+            params=req.queries,
+            data=data,
+            timeout=conf.timeout,
+            **proxy_kwargs,
+        )
+
+        if logger.isEnabledFor(logging.DEBUG):
+            logger.debug(f"{str(req.http_method.name)} {url} {response.status_code}, "
+                         f"headers: {JSON.marshal(redact_for_log(headers))}, "
+                         f"params: {JSON.marshal(redact_query_params_for_log(req.queries))}, "
+                         f"body: {JSON.marshal(redact_for_log(data))}")
+
+        resp = RawResponse()
+        resp.status_code = response.status_code
+        resp.headers = dict(response.headers)
+        resp.content = response.content
+
+        return resp
+
+    @staticmethod
+    async def aexecute(conf: Config, req: BaseRequest, option: Optional[RequestOption] = None) -> RawResponse:
+        if option is None:
+            option = RequestOption()
+
+        # Build the URL
+        url: str = _build_url(conf.domain, req.uri, req.paths)
+
+        # Assemble the headers
+        headers: Dict[str, str] = _build_header(req, option, conf)
+
+        json_, files, data = None, None, None
+        if req.files:
+            # multipart/form-data
+            files = req.files
+            if req.body is not None:
+                data = json.loads(JSON.marshal(req.body))
+        elif req.body is not None:
+            # application/json
+            json_ = json.loads(JSON.marshal(req.body))
+
+        async with httpx.AsyncClient(**_httpx_client_kwargs(conf)) as client:
+            response = await client.request(
+                str(req.http_method.name),
+                url,
+                headers=req.headers,
+                params=req.queries,
+                json=json_,
+                data=data,
+                files=files,
+                timeout=conf.timeout,
+            )
+
+            if logger.isEnabledFor(logging.DEBUG):
+                logger.debug(
+                    f"{str(req.http_method.name)} {url} {response.status_code}"
+                    f"{f', headers: {JSON.marshal(redact_for_log(headers))}' if headers else ''}"
+                    f"{f', params: {JSON.marshal(redact_query_params_for_log(req.queries))}' if req.queries else ''}"
+                    f"{f', body: {JSON.marshal(_redact_body_for_log(json_, files, data))}' if json_ or files or data else ''}"
+                )
+
+            resp = RawResponse()
+            resp.status_code = response.status_code
+            resp.headers = dict(response.headers)
+            resp.content = response.content
+
+            return resp
+
+
+def _build_url(domain: str, uri: str, paths: Dict[str, str]) -> str:
+    if paths is None:
+        paths = {}
+    for key in paths:
+        # Path params must be URL-encoded; safe='' prevents '/', '?', '#'
+        # from passing through unencoded (path traversal / query injection).
+        value = paths[key]
+        if value is None:
+            value = ""
+        encoded = urllib.parse.quote(str(value), safe="")
+        uri = uri.replace(":" + key, encoded)
+
+    return domain + uri
+
+
+def _proxy_kwargs(proxy_url: Optional[str]) -> Dict[str, object]:
+    if not proxy_url:
+        return {}
+    return {"proxies": {"http": proxy_url, "https": proxy_url}}
+
+
+def _sync_requester(conf: Config):
+    proxy_url = getattr(conf, "proxy_url", None)
+    trust_env = getattr(conf, "trust_env_proxy", None)
+    if trust_env is False:
+        session = requests.Session()
+        session.trust_env = False
+        return session.request, _proxy_kwargs(proxy_url)
+    return requests.request, _proxy_kwargs(proxy_url)
+
+
+def _httpx_client_kwargs(conf: Config) -> Dict[str, object]:
+    proxy_url = getattr(conf, "proxy_url", None)
+    trust_env = getattr(conf, "trust_env_proxy", None)
+    kwargs: Dict[str, object] = {}
+    if proxy_url:
+        params = inspect.signature(httpx.AsyncClient).parameters
+        if "proxy" in params:
+            kwargs["proxy"] = proxy_url
+        elif "proxies" in params:
+            kwargs["proxies"] = proxy_url
+        else:
+            raise RuntimeError("installed httpx does not support explicit proxy configuration")
+    if trust_env is not None:
+        kwargs["trust_env"] = trust_env
+    return kwargs
+
+
+def _redact_body_for_log(json_, files, data):
+    return _merge_dicts(
+        redact_for_log(json_),
+        redact_files_for_log(files),
+        redact_for_log(data),
+    )
+
+
+def _build_header(request: BaseRequest, option: RequestOption, conf: Optional[Config] = None) -> Dict[str, str]:
+    headers = request.headers
+
+    # Add the User-Agent
+    source = getattr(conf, "source", None) if conf is not None else None
+    extra_tags = getattr(conf, "extra_ua_tags", None) if conf is not None else None
+    headers[USER_AGENT] = build_user_agent(source=source, extra_tags=extra_tags)
+
+    # Append extra headers
+    if option.headers is not None:
+        for key in option.headers:
+            headers[key] = option.headers[key]
+
+    # Add the token
+    for token_type in request.token_types:
+        if AccessTokenType.TENANT == token_type:
+            headers[AUTHORIZATION] = f"Bearer {option.tenant_access_token}"
+        elif AccessTokenType.APP == token_type:
+            headers[AUTHORIZATION] = f"Bearer {option.app_access_token}"
+        elif AccessTokenType.USER == token_type:
+            headers[AUTHORIZATION] = f"Bearer {option.user_access_token}"
+
+    return headers
+
+
+def _merge_dicts(*dicts):
+    res = {}
+    for d in dicts:
+        if d is not None:
+            res.update(d)
+    return res
diff --git a/lark_channel/core/json.py b/lark_channel/core/json.py
new file mode 100644
index 0000000..f4d8757
--- /dev/null
+++ b/lark_channel/core/json.py
@@ -0,0 +1,63 @@
+import base64
+import copy
+import datetime
+import io
+from json import *
+from typing import *
+
+from .const import UTF_8
+from .type import T
+
+
+class JSON(object):
+
+    @staticmethod
+    def marshal(obj: Any, indent=None) -> Optional[str]:
+        if obj is None:
+            return None
+        return dumps(obj, cls=Encoder, indent=indent, ensure_ascii=False)
+
+    @staticmethod
+    def unmarshal(json_str: str, clazz: Type[T]) -> T:
+        dict_obj = loads(json_str)
+        return clazz(dict_obj)
+
+
+class Encoder(JSONEncoder):
+    def default(self, o: Any) -> Any:
+        if isinstance(o, io.BufferedReader):
+            return o.__str__()
+        if hasattr(o, "__dict__"):
+            return filter_null(copy.deepcopy(vars(o)))
+        if isinstance(o, datetime.datetime):
+            return o.strftime("%Y-%m-%d %H:%M:%S")
+        if isinstance(o, bytes):
+            # Try UTF-8 first (the common case for wire payloads that
+            # happen to be stringly-typed), but fall back to base64 for
+            # genuine binary data (JPEG/PNG/PDF bytes pulled out of a
+            # download response that is later JSON-serialized by caller
+            # code). Without this fallback, any non-UTF-8 byte sequence
+            # raises ``UnicodeDecodeError`` mid-marshal and the whole
+            # response is lost.
+            try:
+                return str(o, encoding=UTF_8)
+            except UnicodeDecodeError:
+                return base64.b64encode(o).decode("ascii")
+        if isinstance(o, int):
+            return int(o)
+        if isinstance(o, float):
+            return float(o)
+        if isinstance(o, set):
+            return list(o)
+        return super().default(o)
+
+
+def filter_null(d: Dict) -> Dict:
+    if isinstance(d, dict):
+        for k, v in list(d.items()):
+            if isinstance(v, dict):
+                filter_null(v)
+            elif v is None:
+                del d[k]
+
+    return d
diff --git a/lark_channel/core/log.py b/lark_channel/core/log.py
new file mode 100644
index 0000000..43ceb30
--- /dev/null
+++ b/lark_channel/core/log.py
@@ -0,0 +1,225 @@
+import logging
+import json
+import re
+import sys
+from typing import Any
+
+logger = logging.getLogger("Lark")
+handler = logging.StreamHandler(sys.stdout)
+handler.setFormatter(logging.Formatter("[Lark] [%(asctime)s] [%(levelname)s] %(message)s"))
+logger.addHandler(handler)
+logger.setLevel(logging.WARNING)
+
+_SENSITIVE_KEY_PARTS = (
+    "authorization",
+    "api_key",
+    "x_api_key",
+    "access_token",
+    "refresh_token",
+    "tenant_access_token",
+    "app_access_token",
+    "user_access_token",
+    "verification_token",
+    "encrypt_key",
+    "private_key",
+    "app_secret",
+    "client_secret",
+    "cookie",
+    "set_cookie",
+    "secret",
+    "password",
+)
+_SENSITIVE_EXACT_KEYS = {
+    "token",
+    "verification_token",
+}
+_JSON_SCALAR_TYPES = (int, float, bool, type(None))
+_AUTHORIZATION_SCHEMES_TO_KEEP = {
+    "basic",
+    "bearer",
+    "digest",
+    "oauth",
+    "token",
+}
+_CAMEL_BOUNDARY_RE = re.compile(r"(?<=[a-z0-9])(?=[A-Z])")
+_NON_KEY_SEPARATOR_RE = re.compile(r"[^0-9A-Za-z]+")
+_SECRET_KEY_PATTERN = (
+    r"authorization|verification[_-]?token|verificationToken|"
+    r"access[_-]?token|accessToken|refresh[_-]?token|refreshToken|"
+    r"tenant[_-]?access[_-]?token|tenantAccessToken|"
+    r"app[_-]?access[_-]?token|appAccessToken|"
+    r"user[_-]?access[_-]?token|userAccessToken|"
+    r"encrypt[_-]?key|encryptKey|app[_-]?secret|appSecret|"
+    r"client[_-]?secret|clientSecret|api[-_]?key|apiKey|"
+    r"x[_-]?api[_-]?key|xApiKey|private[_-]?key|privateKey|"
+    r"set[_-]?cookie|setCookie|cookie|password|secret|token"
+)
+_PRIVATE_KEY_LABEL_RE = r"PRIVATE " + r"KEY"
+_PRIVATE_KEY_BLOCK_RE = re.compile(
+    r"(?is)-----BEGIN [A-Z0-9 ]*"
+    + _PRIVATE_KEY_LABEL_RE
+    + r"-----.*?-----END [A-Z0-9 ]*"
+    + _PRIVATE_KEY_LABEL_RE
+    + r"-----"
+)
+_PRIVATE_KEY_OPEN_RE = re.compile(
+    r"(?is)-----BEGIN [A-Z0-9 ]*" + _PRIVATE_KEY_LABEL_RE + r"-----.*"
+)
+_AUTHORIZATION_HEADER_RE = re.compile(
+    r"(?i)\b(Authorization\s*:\s*)([^\n\r]*)(?:\r?\n[ \t]+[^\n\r]*)*"
+)
+_API_KEY_HEADER_RE = re.compile(
+    r"(?i)\b(X-Api-Key\s*:\s*)[^\n\r]+(?:\r?\n[ \t]+[^\n\r]*)*"
+)
+_COOKIE_HEADER_RE = re.compile(
+    r"(?i)\b((?:Set-)?Cookie\s*:\s*)[^\n\r]*(?:\r?\n[ \t]+[^\n\r]*)*"
+)
+_QUOTED_ASSIGNMENT_SECRET_RE = re.compile(
+    rf"(?is)\b({_SECRET_KEY_PATTERN})([\"']?\s*[:=]\s*)([\"']).*?\3"
+)
+_UNCLOSED_QUOTED_ASSIGNMENT_SECRET_RE = re.compile(
+    rf"(?is)\b({_SECRET_KEY_PATTERN})([\"']?\s*[:=]\s*)([\"']).*"
+)
+_ASSIGNMENT_SECRET_RE = re.compile(
+    rf"(?i)\b({_SECRET_KEY_PATTERN})([\"']?\s*[:=]\s*)[^,\n\r&;]+"
+)
+_BEARER_RE = re.compile(r"(?i)\bBearer\s+[^\n\r]+")
+
+
+def _is_sensitive_key(key: Any) -> bool:
+    normalized = _normalize_key(key)
+    return normalized in _SENSITIVE_EXACT_KEYS or any(
+        part in normalized for part in _SENSITIVE_KEY_PARTS
+    )
+
+
+def _normalize_key(key: Any) -> str:
+    text = _CAMEL_BOUNDARY_RE.sub("_", str(key))
+    return _NON_KEY_SEPARATOR_RE.sub("_", text).strip("_").lower()
+
+
+def _redacted_value(key: Any, value: Any) -> str:
+    if "authorization" in _normalize_key(key).split("_") and isinstance(value, str):
+        return _redact_authorization_value(value)
+    return "***"
+
+
+def _redact_authorization_value(value: str) -> str:
+    stripped = value.strip()
+    scheme = stripped.split(None, 1)[0] if stripped else ""
+    if scheme.lower() in _AUTHORIZATION_SCHEMES_TO_KEEP and len(stripped) > len(scheme):
+        return f"{scheme} ***"
+    return "***"
+
+
+def _redact_authorization_header(match: re.Match) -> str:
+    return f"{match.group(1)}{_redact_authorization_value(match.group(2))}"
+
+
+def _redact_free_text(value: str) -> str:
+    value = _PRIVATE_KEY_BLOCK_RE.sub("<redacted private key>", value)
+    value = _PRIVATE_KEY_OPEN_RE.sub("<redacted private key>", value)
+    value = _AUTHORIZATION_HEADER_RE.sub(_redact_authorization_header, value)
+    value = _BEARER_RE.sub("Bearer ***", value)
+    value = _API_KEY_HEADER_RE.sub(lambda m: f"{m.group(1)}***", value)
+    value = _COOKIE_HEADER_RE.sub(lambda m: f"{m.group(1)}***", value)
+    value = _QUOTED_ASSIGNMENT_SECRET_RE.sub(
+        lambda m: f"{m.group(1)}{m.group(2)}{m.group(3)}***{m.group(3)}",
+        value,
+    )
+    value = _UNCLOSED_QUOTED_ASSIGNMENT_SECRET_RE.sub(
+        lambda m: f"{m.group(1)}{m.group(2)}{m.group(3)}***",
+        value,
+    )
+    return _ASSIGNMENT_SECRET_RE.sub(
+        lambda m: f"{m.group(1)}{m.group(2)}***",
+        value,
+    )
+
+
+def _redact_bytes_for_log(value: bytes, *, _depth: int) -> Any:
+    try:
+        text = value.decode("utf-8")
+    except UnicodeDecodeError:
+        return f"<{len(value)} bytes>"
+    stripped = text.strip()
+    if stripped.startswith(("{", "[")):
+        try:
+            return redact_for_log(json.loads(stripped), _depth=_depth + 1)
+        except (ValueError, RecursionError):
+            pass
+    return f"<{len(value)} bytes>"
+
+
+def redact_for_log(value: Any, *, _depth: int = 0) -> Any:
+    if _depth > 8:
+        return "<redacted>"
+    if isinstance(value, _JSON_SCALAR_TYPES):
+        return value
+    if isinstance(value, bytes):
+        return _redact_bytes_for_log(value, _depth=_depth)
+    if isinstance(value, str):
+        stripped = value.strip()
+        if stripped.startswith(("{", "[")):
+            try:
+                return redact_for_log(json.loads(stripped), _depth=_depth + 1)
+            except (ValueError, RecursionError):
+                return f"<{len(value)} chars>"
+        return _redact_free_text(value)
+    if isinstance(value, dict):
+        return {
+            key: _redacted_value(key, item)
+            if _is_sensitive_key(key)
+            else redact_for_log(item, _depth=_depth + 1)
+            for key, item in value.items()
+        }
+    if isinstance(value, (list, tuple)):
+        return [redact_for_log(item, _depth=_depth + 1) for item in value]
+    return f"<{type(value).__name__}>"
+
+
+def redact_query_params_for_log(value: Any, *, _depth: int = 0) -> Any:
+    if _depth > 8:
+        return "<redacted>"
+    if isinstance(value, dict):
+        return {
+            key: _redacted_value(key, item)
+            if _is_sensitive_key(key)
+            else redact_for_log(item, _depth=_depth + 1)
+            for key, item in value.items()
+        }
+    if isinstance(value, (list, tuple)):
+        return [_redact_query_param_item(item, _depth=_depth + 1) for item in value]
+    return redact_for_log(value, _depth=_depth)
+
+
+def _redact_query_param_item(item: Any, *, _depth: int) -> Any:
+    if isinstance(item, (list, tuple)) and len(item) == 2:
+        key, value = item
+        redacted = (
+            _redacted_value(key, value)
+            if _is_sensitive_key(key)
+            else redact_for_log(value, _depth=_depth + 1)
+        )
+        if isinstance(item, tuple):
+            return (key, redacted)
+        return [key, redacted]
+    return redact_query_params_for_log(item, _depth=_depth)
+
+
+def redact_files_for_log(value: Any, *, _depth: int = 0) -> Any:
+    if _depth > 8:
+        return "<file upload>"
+    if value is None:
+        return None
+    if isinstance(value, dict):
+        return {key: "<file upload>" for key in value}
+    if isinstance(value, (list, tuple)):
+        redacted = []
+        for item in value:
+            if isinstance(item, (list, tuple)) and len(item) == 2:
+                redacted.append((item[0], "<file upload>"))
+            else:
+                redacted.append("<file upload>")
+        return redacted
+    return "<file upload>"
diff --git a/lark_channel/core/model/__init__.py b/lark_channel/core/model/__init__.py
new file mode 100644
index 0000000..350df35
--- /dev/null
+++ b/lark_channel/core/model/__init__.py
@@ -0,0 +1,6 @@
+from .base_request import *
+from .base_response import *
+from .config import *
+from .raw_request import *
+from .raw_response import *
+from .request_option import *
diff --git a/lark_channel/core/model/base_request.py b/lark_channel/core/model/base_request.py
new file mode 100644
index 0000000..18bfdeb
--- /dev/null
+++ b/lark_channel/core/model/base_request.py
@@ -0,0 +1,63 @@
+from typing import *
+
+from lark_channel.core import HttpMethod, AccessTokenType
+
+
+class BaseRequest(object):
+    def __init__(self) -> None:
+        self.http_method: Optional[HttpMethod] = None
+        self.uri: Optional[str] = None
+        self.token_types: Set[AccessTokenType] = set()
+        self.paths: Dict[str, str] = {}
+        self.queries: List[Tuple[str, str]] = []
+        self.headers: Dict[str, str] = {}
+        self.body: Any = None
+        self.files: Optional[Dict] = None
+
+    def add_query(self, k: str, v: Any) -> None:
+        if isinstance(v, (list, tuple)):
+            for i in v:
+                self.queries.append((k, str(i)))
+        else:
+            self.queries.append((k, str(v)))
+
+    @staticmethod
+    def builder() -> "BaseRequestBuilder":
+        return BaseRequestBuilder()
+
+
+class BaseRequestBuilder(object):
+
+    def __init__(self) -> None:
+        self._base_request: BaseRequest = BaseRequest()
+
+    def http_method(self, http_method: HttpMethod) -> "BaseRequestBuilder":
+        self._base_request.http_method = http_method
+        return self
+
+    def uri(self, uri: str) -> "BaseRequestBuilder":
+        self._base_request.uri = uri
+        return self
+
+    def token_types(self, token_types: Set[AccessTokenType]) -> "BaseRequestBuilder":
+        self._base_request.token_types = token_types
+        return self
+
+    def paths(self, paths: Dict[str, str]) -> "BaseRequestBuilder":
+        self._base_request.paths = paths
+        return self
+
+    def queries(self, queries: List[Tuple[str, str]]) -> "BaseRequestBuilder":
+        self._base_request.queries = queries
+        return self
+
+    def headers(self, headers: Dict[str, str]) -> "BaseRequestBuilder":
+        self._base_request.headers = headers
+        return self
+
+    def body(self, body: Any) -> "BaseRequestBuilder":
+        self._base_request.body = body
+        return self
+
+    def build(self) -> BaseRequest:
+        return self._base_request
diff --git a/lark_channel/core/model/base_response.py b/lark_channel/core/model/base_response.py
new file mode 100644
index 0000000..e22168c
--- /dev/null
+++ b/lark_channel/core/model/base_response.py
@@ -0,0 +1,28 @@
+from typing import *
+
+from lark_channel.core.const import X_TT_LOGID
+from lark_channel.core.construct import init
+from .raw_response import RawResponse
+from .error import Error
+
+
+class BaseResponse(object):
+    _types = {}
+
+    def __init__(self, d=None):
+        self.raw: Optional[RawResponse] = None
+        self.code: Optional[int] = None
+        self.msg: Optional[str] = None
+        self.error: Optional[Error] = None
+        init(self, d, self._types)
+
+    def success(self):
+        return self.code is not None and self.code == 0
+
+    def get_log_id(self) -> Optional[str]:
+        if self.raw is None or self.raw.headers is None:
+            return None
+        return self.raw.headers.get(X_TT_LOGID)
+
+    def get_troubleshooter(self) -> Optional[str]:
+        return self.error.troubleshooter if self.error is not None else None
diff --git a/lark_channel/core/model/config.py b/lark_channel/core/model/config.py
new file mode 100644
index 0000000..4e70ff0
--- /dev/null
+++ b/lark_channel/core/model/config.py
@@ -0,0 +1,23 @@
+from typing import Any, List, Optional
+
+from lark_channel.core import AppType, LogLevel
+from lark_channel.core.cache import ICache
+from lark_channel.core.const import FEISHU_DOMAIN
+
+
+class Config(object):
+    def __init__(self) -> None:
+        self.app_id: Optional[str] = None
+        self.app_secret: Optional[str] = None
+        self.domain: str = FEISHU_DOMAIN  # Domain; defaults to https://open.feishu.cn
+        self.timeout: Optional[float] = 30  # client timeout in seconds (default 30s); override via ClientBuilder.timeout()
+        self.app_type: AppType = AppType.SELF  # App type; defaults to a self-built app. When set to ISV, configure tenant_key in request_option
+        self.enable_set_token: bool = False  # Whether manual token setting is allowed; disabled by default. When enabled, configure the token in request_option
+        self.cache: Optional[ICache] = None  # Custom cache; defaults to the built-in local cache
+        self.log_level: LogLevel = LogLevel.WARNING  # Log level; defaults to WARNING
+        self.source: Optional[str] = None  # caller identifier, appended to UA as `source/<name>`
+        self.proxy_url: Optional[str] = None
+        self.trust_env_proxy: Optional[bool] = None
+        # Internal: sub-modules (e.g. channel) append bare UA tags from here.
+        self.extra_ua_tags: Optional[List[str]] = None
+        self.security: Optional[Any] = None
diff --git a/lark_channel/core/model/error.py b/lark_channel/core/model/error.py
new file mode 100644
index 0000000..4e070fe
--- /dev/null
+++ b/lark_channel/core/model/error.py
@@ -0,0 +1,75 @@
+from typing import *
+
+from lark_channel.core.construct import init
+
+
+class ErrorDetail(object):
+    _types = {
+        "key": str,
+        "value": str,
+    }
+
+    def __init__(self, d=None):
+        self.key: Optional[str] = None
+        self.value: Optional[str] = None
+        init(self, d, self._types)
+
+
+class ErrorPermissionViolation(object):
+    _types = {
+        "type": str,
+        "subject": str,
+        "description": str,
+    }
+
+    def __init__(self, d=None):
+        self.type: Optional[str] = None
+        self.subject: Optional[str] = None
+        self.description: Optional[str] = None
+        init(self, d, self._types)
+
+
+class ErrorFieldViolation(object):
+    _types = {
+        "field": str,
+        "value": str,
+        "description": str,
+    }
+
+    def __init__(self, d=None):
+        self.field: Optional[str] = None
+        self.value: Optional[str] = None
+        self.description: Optional[str] = None
+        init(self, d, self._types)
+
+
+class ErrorHelp(object):
+    _types = {
+        "url": str,
+        "description": str,
+    }
+
+    def __init__(self, d=None):
+        self.url: Optional[str] = None
+        self.description: Optional[str] = None
+        init(self, d, self._types)
+
+
+class Error(object):
+    _types = {
+        "log_id": str,
+        "troubleshooter": str,
+        "details": List[ErrorDetail],
+        "permission_violations": List[ErrorPermissionViolation],
+        "field_violations": List[ErrorFieldViolation],
+        "helps": List[ErrorHelp],
+    }
+
+    def __init__(self, d=None):
+        self.log_id: Optional[str] = None
+        self.troubleshooter: Optional[str] = None
+        self.details: Optional[List[ErrorDetail]] = None
+        self.permission_violations: Optional[List[ErrorPermissionViolation]] = None
+        self.field_violations: Optional[List[ErrorFieldViolation]] = None
+        self.helps: Optional[List[ErrorHelp]] = None
+        init(self, d, self._types)
diff --git a/lark_channel/core/model/raw_request.py b/lark_channel/core/model/raw_request.py
new file mode 100644
index 0000000..b84f00e
--- /dev/null
+++ b/lark_channel/core/model/raw_request.py
@@ -0,0 +1,8 @@
+from typing import *
+
+
+class RawRequest(object):
+    def __init__(self):
+        self.uri: Optional[str] = None
+        self.headers: Dict[str, str] = {}
+        self.body: Optional[bytes] = None
diff --git a/lark_channel/core/model/raw_response.py b/lark_channel/core/model/raw_response.py
new file mode 100644
index 0000000..24fa648
--- /dev/null
+++ b/lark_channel/core/model/raw_response.py
@@ -0,0 +1,14 @@
+from typing import Optional, Dict
+
+from lark_channel.core.const import CONTENT_TYPE
+
+
+class RawResponse(object):
+
+    def __init__(self):
+        self.status_code: Optional[int] = None
+        self.headers: Dict[str, str] = {}
+        self.content: Optional[bytes] = None
+
+    def set_content_type(self, content_type: str) -> None:
+        self.headers[CONTENT_TYPE] = content_type
diff --git a/lark_channel/core/model/request_option.py b/lark_channel/core/model/request_option.py
new file mode 100644
index 0000000..a7df368
--- /dev/null
+++ b/lark_channel/core/model/request_option.py
@@ -0,0 +1,48 @@
+from typing import Optional, Dict
+
+
+class RequestOption(object):
+    def __init__(self):
+        self.app_ticket: Optional[str] = None
+        self.tenant_key: Optional[str] = None  # Tenant key; required when app_type = ISV
+        self.user_access_token: Optional[str] = None
+        self.tenant_access_token: Optional[str] = None
+        self.app_access_token: Optional[str] = None
+        self.headers: Dict[str, str] = {}
+
+    @staticmethod
+    def builder() -> "RequestOptionBuilder":
+        return RequestOptionBuilder()
+
+
+class RequestOptionBuilder(object):
+
+    def __init__(self) -> None:
+        self._request_option: RequestOption = RequestOption()
+
+    def app_ticket(self, app_ticket: str) -> "RequestOptionBuilder":
+        self._request_option.app_ticket = app_ticket
+        return self
+
+    def tenant_key(self, tenant_key: str) -> "RequestOptionBuilder":
+        self._request_option.tenant_key = tenant_key
+        return self
+
+    def user_access_token(self, user_access_token: str) -> "RequestOptionBuilder":
+        self._request_option.user_access_token = user_access_token
+        return self
+
+    def tenant_access_token(self, tenant_access_token: str) -> "RequestOptionBuilder":
+        self._request_option.tenant_access_token = tenant_access_token
+        return self
+
+    def app_access_token(self, app_access_token: str) -> "RequestOptionBuilder":
+        self._request_option.app_access_token = app_access_token
+        return self
+
+    def headers(self, headers: Dict[str, str]) -> "RequestOptionBuilder":
+        self._request_option.headers = headers
+        return self
+
+    def build(self) -> RequestOption:
+        return self._request_option
diff --git a/lark_channel/core/token/__init__.py b/lark_channel/core/token/__init__.py
new file mode 100644
index 0000000..e92bff6
--- /dev/null
+++ b/lark_channel/core/token/__init__.py
@@ -0,0 +1,8 @@
+from .access_token_response import *
+from .auth import *
+from .create_isv_app_token_request import *
+from .create_isv_tenant_token_request import *
+from .create_self_app_token_request import *
+from .create_self_tenant_token_request import *
+from .create_token_request_body import *
+from .manager import *
diff --git a/lark_channel/core/token/access_token_response.py b/lark_channel/core/token/access_token_response.py
new file mode 100644
index 0000000..0a53f69
--- /dev/null
+++ b/lark_channel/core/token/access_token_response.py
@@ -0,0 +1,15 @@
+from typing import Optional
+
+from lark_channel.core.construct import init
+from lark_channel.core.model import BaseResponse
+
+
+class AccessTokenResponse(BaseResponse):
+    _types = {}
+
+    def __init__(self, d):
+        super().__init__(d)
+        self.tenant_access_token: Optional[str] = None
+        self.app_access_token: Optional[str] = None
+        self.expire: Optional[int] = None
+        init(self, d, self._types)
diff --git a/lark_channel/core/token/auth.py b/lark_channel/core/token/auth.py
new file mode 100644
index 0000000..3c3bbe0
--- /dev/null
+++ b/lark_channel/core/token/auth.py
@@ -0,0 +1,53 @@
+from lark_channel.core.exception import NoAuthorizationException
+from lark_channel.core.model import *
+from lark_channel.core.utils import Strings
+from .manager import TokenManager
+
+
+def verify(config: Config, request: BaseRequest, option: RequestOption) -> None:
+    # Endpoint does not require a token
+    if len(request.token_types) == 0:
+        return
+
+    # When token config is enabled, the token must be passed manually
+    if config.enable_set_token:
+        if Strings.is_not_empty(option.tenant_access_token) and AccessTokenType.TENANT in request.token_types:
+            request.token_types = {AccessTokenType.TENANT}
+            return
+        if Strings.is_not_empty(option.app_access_token) and AccessTokenType.APP in request.token_types:
+            request.token_types = {AccessTokenType.APP}
+            return
+        if Strings.is_not_empty(option.user_access_token) and AccessTokenType.USER in request.token_types:
+            request.token_types = {AccessTokenType.USER}
+            return
+
+    # When token config is disabled, obtain the token from app_id/app_secret
+    if Strings.is_empty(config.app_id) or Strings.is_empty(config.app_secret):
+        raise NoAuthorizationException("app_id or app_secret not found")
+
+    if AccessTokenType.TENANT in request.token_types:
+        tenant_access_token: str
+        if AppType.SELF == config.app_type:
+            tenant_access_token = TokenManager.get_self_tenant_token(config)
+        else:
+            if Strings.is_empty(option.tenant_key):
+                raise NoAuthorizationException("tenant_key not found")
+            tenant_access_token = TokenManager.get_isv_tenant_token(config, option.tenant_key, option.app_ticket)
+        option.tenant_access_token = tenant_access_token
+        request.token_types = {AccessTokenType.TENANT}
+        return
+
+    if AccessTokenType.APP in request.token_types:
+        app_access_token: str
+        if AppType.SELF == config.app_type:
+            app_access_token = TokenManager.get_self_app_token(config)
+        else:
+            app_access_token = TokenManager.get_isv_app_token(config, option.app_ticket)
+        option.app_access_token = app_access_token
+        request.token_types = {AccessTokenType.APP}
+        return
+
+    if AccessTokenType.USER in request.token_types:
+        if Strings.is_empty(option.user_access_token):
+            raise NoAuthorizationException("user_access_token not found")
+        raise NoAuthorizationException("need enable set token")
diff --git a/lark_channel/core/token/create_isv_app_token_request.py b/lark_channel/core/token/create_isv_app_token_request.py
new file mode 100644
index 0000000..265d511
--- /dev/null
+++ b/lark_channel/core/token/create_isv_app_token_request.py
@@ -0,0 +1,35 @@
+from typing import Optional
+
+from lark_channel.core import HttpMethod
+from lark_channel.core.model import BaseRequest
+from .create_token_request_body import CreateTokenRequestBody
+
+
+class CreateIsvAppTokenRequest(BaseRequest):
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.request_body: Optional[CreateTokenRequestBody] = None
+
+    @staticmethod
+    def builder() -> "CreateIsvAppTokenRequestBuilder":
+        return CreateIsvAppTokenRequestBuilder()
+
+
+class CreateIsvAppTokenRequestBuilder(object):
+
+    def __init__(
+            self,
+            create_isv_app_token_request: CreateIsvAppTokenRequest = CreateIsvAppTokenRequest()
+    ) -> None:
+        create_isv_app_token_request.http_method = HttpMethod.POST
+        create_isv_app_token_request.uri = "/open-apis/auth/v3/app_access_token"
+        self.__create_isv_app_token_request: CreateIsvAppTokenRequest = create_isv_app_token_request
+
+    def request_body(self, request_body: CreateTokenRequestBody) -> "CreateIsvAppTokenRequestBuilder":
+        self.__create_isv_app_token_request.request_body = request_body
+        self.__create_isv_app_token_request.body = request_body
+        return self
+
+    def build(self) -> CreateIsvAppTokenRequest:
+        return self.__create_isv_app_token_request
diff --git a/lark_channel/core/token/create_isv_tenant_token_request.py b/lark_channel/core/token/create_isv_tenant_token_request.py
new file mode 100644
index 0000000..1b7878e
--- /dev/null
+++ b/lark_channel/core/token/create_isv_tenant_token_request.py
@@ -0,0 +1,35 @@
+from typing import Optional
+
+from lark_channel.core import HttpMethod
+from lark_channel.core.model import BaseRequest
+from .create_token_request_body import CreateTokenRequestBody
+
+
+class CreateIsvTenantTokenRequest(BaseRequest):
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.request_body: Optional[CreateTokenRequestBody] = None
+
+    @staticmethod
+    def builder() -> "CreateIsvTenantTokenRequestBuilder":
+        return CreateIsvTenantTokenRequestBuilder()
+
+
+class CreateIsvTenantTokenRequestBuilder(object):
+
+    def __init__(
+            self,
+            create_isv_tenant_token_request: CreateIsvTenantTokenRequest = CreateIsvTenantTokenRequest()
+    ) -> None:
+        create_isv_tenant_token_request.http_method = HttpMethod.POST
+        create_isv_tenant_token_request.uri = "/open-apis/auth/v3/tenant_access_token"
+        self.__create_isv_tenant_token_request: CreateIsvTenantTokenRequest = create_isv_tenant_token_request
+
+    def request_body(self, request_body: CreateTokenRequestBody) -> "CreateIsvTenantTokenRequestBuilder":
+        self.__create_isv_tenant_token_request.request_body = request_body
+        self.__create_isv_tenant_token_request.body = request_body
+        return self
+
+    def build(self) -> CreateIsvTenantTokenRequest:
+        return self.__create_isv_tenant_token_request
diff --git a/lark_channel/core/token/create_self_app_token_request.py b/lark_channel/core/token/create_self_app_token_request.py
new file mode 100644
index 0000000..0c1b5b0
--- /dev/null
+++ b/lark_channel/core/token/create_self_app_token_request.py
@@ -0,0 +1,35 @@
+from typing import Optional
+
+from lark_channel.core import HttpMethod
+from lark_channel.core.model import BaseRequest
+from .create_token_request_body import CreateTokenRequestBody
+
+
+class CreateSelfAppTokenRequest(BaseRequest):
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.request_body: Optional[CreateTokenRequestBody] = None
+
+    @staticmethod
+    def builder() -> "CreateSelfAppTokenRequestBuilder":
+        return CreateSelfAppTokenRequestBuilder()
+
+
+class CreateSelfAppTokenRequestBuilder(object):
+
+    def __init__(
+            self,
+            create_self_app_token_request: CreateSelfAppTokenRequest = CreateSelfAppTokenRequest()
+    ) -> None:
+        create_self_app_token_request.http_method = HttpMethod.POST
+        create_self_app_token_request.uri = "/open-apis/auth/v3/app_access_token/internal"
+        self.__create_self_app_token_request: CreateSelfAppTokenRequest = create_self_app_token_request
+
+    def request_body(self, request_body: CreateTokenRequestBody) -> "CreateSelfAppTokenRequestBuilder":
+        self.__create_self_app_token_request.request_body = request_body
+        self.__create_self_app_token_request.body = request_body
+        return self
+
+    def build(self) -> CreateSelfAppTokenRequest:
+        return self.__create_self_app_token_request
diff --git a/lark_channel/core/token/create_self_tenant_token_request.py b/lark_channel/core/token/create_self_tenant_token_request.py
new file mode 100644
index 0000000..baa1f00
--- /dev/null
+++ b/lark_channel/core/token/create_self_tenant_token_request.py
@@ -0,0 +1,35 @@
+from typing import Optional
+
+from lark_channel.core import HttpMethod
+from lark_channel.core.model import BaseRequest
+from .create_token_request_body import CreateTokenRequestBody
+
+
+class CreateSelfTenantTokenRequest(BaseRequest):
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.request_body: Optional[CreateTokenRequestBody] = None
+
+    @staticmethod
+    def builder() -> "CreateSelfTenantTokenRequestBuilder":
+        return CreateSelfTenantTokenRequestBuilder()
+
+
+class CreateSelfTenantTokenRequestBuilder(object):
+
+    def __init__(
+            self,
+            create_self_tenant_token_request: CreateSelfTenantTokenRequest = CreateSelfTenantTokenRequest()
+    ) -> None:
+        create_self_tenant_token_request.http_method = HttpMethod.POST
+        create_self_tenant_token_request.uri = "/open-apis/auth/v3/tenant_access_token/internal"
+        self.__create_self_tenant_token_request: CreateSelfTenantTokenRequest = create_self_tenant_token_request
+
+    def request_body(self, request_body: CreateTokenRequestBody) -> "CreateSelfTenantTokenRequestBuilder":
+        self.__create_self_tenant_token_request.request_body = request_body
+        self.__create_self_tenant_token_request.body = request_body
+        return self
+
+    def build(self) -> CreateSelfTenantTokenRequest:
+        return self.__create_self_tenant_token_request
diff --git a/lark_channel/core/token/create_token_request_body.py b/lark_channel/core/token/create_token_request_body.py
new file mode 100644
index 0000000..5cc510c
--- /dev/null
+++ b/lark_channel/core/token/create_token_request_body.py
@@ -0,0 +1,45 @@
+from typing import Optional
+
+
+class CreateTokenRequestBody(object):
+    def __init__(self) -> None:
+        self.app_id: Optional[str] = None
+        self.app_secret: Optional[str] = None
+        self.app_ticket: Optional[str] = None
+        self.app_access_token: Optional[str] = None
+        self.tenant_key: Optional[str] = None
+
+    @staticmethod
+    def builder() -> "CreateTokenRequestBodyBuilder":
+        return CreateTokenRequestBodyBuilder()
+
+
+class CreateTokenRequestBodyBuilder(object):
+    def __init__(
+            self,
+            create_token_request_body: CreateTokenRequestBody = CreateTokenRequestBody()
+    ) -> None:
+        self.__create_token_request_body: CreateTokenRequestBody = create_token_request_body
+
+    def app_id(self, app_id: str) -> "CreateTokenRequestBodyBuilder":
+        self.__create_token_request_body.app_id = app_id
+        return self
+
+    def app_secret(self, app_secret: str) -> "CreateTokenRequestBodyBuilder":
+        self.__create_token_request_body.app_secret = app_secret
+        return self
+
+    def app_ticket(self, app_ticket: str) -> "CreateTokenRequestBodyBuilder":
+        self.__create_token_request_body.app_ticket = app_ticket
+        return self
+
+    def app_access_token(self, app_access_token: str) -> "CreateTokenRequestBodyBuilder":
+        self.__create_token_request_body.app_access_token = app_access_token
+        return self
+
+    def tenant_key(self, tenant_key: str) -> "CreateTokenRequestBodyBuilder":
+        self.__create_token_request_body.tenant_key = tenant_key
+        return self
+
+    def build(self) -> "CreateTokenRequestBody":
+        return self.__create_token_request_body
diff --git a/lark_channel/core/token/manager.py b/lark_channel/core/token/manager.py
new file mode 100644
index 0000000..9219bb6
--- /dev/null
+++ b/lark_channel/core/token/manager.py
@@ -0,0 +1,239 @@
+import time
+import urllib.parse
+from typing import Optional
+
+from lark_channel.core import JSON, Strings
+from lark_channel.core.cache import *
+from lark_channel.core.const import UTF_8
+from lark_channel.core.exception import ObtainAccessTokenException
+from lark_channel.core.http import Transport
+from lark_channel.core.model import Config, RawResponse
+from .access_token_response import AccessTokenResponse
+from .create_isv_app_token_request import CreateIsvAppTokenRequest
+from .create_isv_tenant_token_request import CreateIsvTenantTokenRequest
+from .create_self_app_token_request import CreateSelfAppTokenRequest
+from .create_self_tenant_token_request import CreateSelfTenantTokenRequest
+from .create_token_request_body import CreateTokenRequestBody
+
+
+class TokenManager(object):
+    cache: ICache = LocalCache.instance()
+
+    @staticmethod
+    def get_self_app_token(conf: Config) -> str:
+        # Read from cache
+        legacy_cache_key = f"self_app_token:{conf.app_id}"
+        cache_key = _domain_scoped_cache_key(conf, legacy_cache_key)
+        token = _get_cached_token(
+            conf,
+            cache_key=cache_key,
+            legacy_cache_key=legacy_cache_key,
+            token_kind="self_app_token",
+        )
+        if Strings.is_not_empty(token):
+            return token
+
+        # On cache miss, request a new token
+        req: CreateSelfAppTokenRequest = CreateSelfAppTokenRequest.builder() \
+            .request_body(CreateTokenRequestBody.builder()
+                          .app_id(conf.app_id)
+                          .app_secret(conf.app_secret)
+                          .build()) \
+            .build()
+        raw: RawResponse = Transport.execute(conf, req)
+        resp = JSON.unmarshal(str(raw.content, UTF_8), AccessTokenResponse)
+
+        if not resp.success():
+            raise ObtainAccessTokenException("obtain self app access token failed", resp.code, resp.msg)
+
+        # Write to cache
+        token = resp.app_access_token
+        expire = time.time() + resp.expire - 10 * 60  # Expire 10 minutes early
+        TokenManager.cache.set(cache_key, token, int(expire))
+
+        return token
+
+    @staticmethod
+    def get_self_tenant_token(config: Config) -> str:
+        # Read from cache
+        legacy_cache_key = f"self_tenant_token:{config.app_id}"
+        cache_key = _domain_scoped_cache_key(config, legacy_cache_key)
+        token = _get_cached_token(
+            config,
+            cache_key=cache_key,
+            legacy_cache_key=legacy_cache_key,
+            token_kind="self_tenant_token",
+        )
+        if Strings.is_not_empty(token):
+            return token
+
+        # On cache miss, request a new token
+        req: CreateSelfTenantTokenRequest = CreateSelfTenantTokenRequest.builder() \
+            .request_body(CreateTokenRequestBody.builder()
+                          .app_id(config.app_id)
+                          .app_secret(config.app_secret)
+                          .build()) \
+            .build()
+        raw: RawResponse = Transport.execute(config, req)
+        resp = JSON.unmarshal(str(raw.content, UTF_8), AccessTokenResponse)
+
+        if not resp.success():
+            raise ObtainAccessTokenException("obtain self tenant access token failed", resp.code, resp.msg)
+
+        # Write to cache
+        token = resp.tenant_access_token
+        expire = time.time() + resp.expire - 10 * 60  # Expire 10 minutes early
+        TokenManager.cache.set(cache_key, token, int(expire))
+
+        return token
+
+    @staticmethod
+    def get_isv_app_token(config: Config, app_ticket: str) -> str:
+        # Read from cache
+        legacy_cache_key = f"isv_app_token:{config.app_id}"
+        cache_key = _domain_scoped_cache_key(config, legacy_cache_key)
+        token = _get_cached_token(
+            config,
+            cache_key=cache_key,
+            legacy_cache_key=legacy_cache_key,
+            token_kind="isv_app_token",
+        )
+        if Strings.is_not_empty(token):
+            return token
+
+        if Strings.is_empty(app_ticket):
+            pass
+
+        # On cache miss, request a new token
+        req: CreateIsvAppTokenRequest = CreateIsvAppTokenRequest.builder() \
+            .request_body(CreateTokenRequestBody.builder()
+                          .app_id(config.app_id)
+                          .app_secret(config.app_secret)
+                          .app_ticket(app_ticket).build()) \
+            .build()
+        raw: RawResponse = Transport.execute(config, req)
+        resp = JSON.unmarshal(str(raw.content, UTF_8), AccessTokenResponse)
+
+        if not resp.success():
+            raise ObtainAccessTokenException("obtain isv app access token failed", resp.code, resp.msg)
+
+        # Write to cache
+        token = resp.app_access_token
+        expire = time.time() + resp.expire - 10 * 60  # Expire 10 minutes early
+        TokenManager.cache.set(cache_key, token, int(expire))
+
+        return token
+
+    @staticmethod
+    def get_isv_tenant_token(config: Config, tenant_key: str, app_ticket: str) -> str:
+        # Read from cache
+        legacy_cache_key = f"isv_tenant_token:{config.app_id}:{tenant_key}"
+        cache_key = _domain_scoped_cache_key(config, legacy_cache_key)
+        token = _get_cached_token(
+            config,
+            cache_key=cache_key,
+            legacy_cache_key=legacy_cache_key,
+            token_kind="isv_tenant_token",
+        )
+        if Strings.is_not_empty(token):
+            return token
+
+        app_token = TokenManager.get_isv_app_token(config, app_ticket)
+        # On cache miss, request a new token
+        req: CreateIsvTenantTokenRequest = CreateIsvTenantTokenRequest.builder() \
+            .request_body(CreateTokenRequestBody.builder()
+                          .app_access_token(app_token)
+                          .tenant_key(tenant_key).build()) \
+            .build()
+        raw: RawResponse = Transport.execute(config, req)
+        resp = JSON.unmarshal(str(raw.content, UTF_8), AccessTokenResponse)
+
+        if not resp.success():
+            raise ObtainAccessTokenException("obtain isv tenant access token failed", resp.code, resp.msg)
+
+        # Write to cache
+        token = resp.tenant_access_token
+        expire = time.time() + resp.expire - 10 * 60  # Expire 10 minutes early
+        TokenManager.cache.set(cache_key, token, int(expire))
+
+        return token
+
+
+def _domain_scoped_cache_key(config: Config, legacy_cache_key: str) -> str:
+    return f"{legacy_cache_key}:v2:{_domain_cache_origin(config)}"
+
+
+def _domain_cache_origin(config: Config) -> str:
+    domain = getattr(config, "domain", "") or ""
+    parsed = urllib.parse.urlsplit(domain)
+    if not parsed.scheme or not parsed.netloc:
+        return domain.rstrip("/")
+    return urllib.parse.urlunsplit(
+        (parsed.scheme.lower(), parsed.netloc.lower(), "", "", "")
+    )
+
+
+def _get_cached_token(
+    config: Config,
+    *,
+    cache_key: str,
+    legacy_cache_key: str,
+    token_kind: str,
+) -> Optional[str]:
+    token = TokenManager.cache.get(cache_key)
+    if Strings.is_not_empty(token):
+        return token
+    if not _legacy_token_cache_fallback_enabled(config):
+        return None
+    token = TokenManager.cache.get(legacy_cache_key)
+    if Strings.is_not_empty(token):
+        _record_legacy_token_cache_fallback(
+            config,
+            token_kind=token_kind,
+            legacy_cache_key=legacy_cache_key,
+            cache_key=cache_key,
+        )
+        return token
+    return None
+
+
+def _legacy_token_cache_fallback_enabled(config: Config) -> bool:
+    security = getattr(config, "security", None)
+    if security is None:
+        return True
+    effective = getattr(security, "effective_legacy_token_cache_fallback", None)
+    if effective is not None:
+        return bool(effective)
+    return bool(getattr(security, "legacy_token_cache_fallback", True))
+
+
+def _record_legacy_token_cache_fallback(
+    config: Config,
+    *,
+    token_kind: str,
+    legacy_cache_key: str,
+    cache_key: str,
+) -> None:
+    security = getattr(config, "security", None)
+    recorder = getattr(security, "audit_recorder", None)
+    if not callable(getattr(recorder, "record", None)):
+        return
+    from lark_channel.event.security import (
+        REASON_TOKEN_CACHE_LEGACY_FALLBACK,
+        should_record_security_audit,
+    )
+
+    if not should_record_security_audit(security):
+        return
+
+    recorder.record(
+        REASON_TOKEN_CACHE_LEGACY_FALLBACK,
+        mode=getattr(security, "mode", "compat"),
+        action="fallback",
+        details={
+            "token_kind": token_kind,
+            "domain": _domain_cache_origin(config),
+            "legacy_cache_key": legacy_cache_key,
+            "cache_key": cache_key,
+        },
+    )
diff --git a/lark_channel/core/token/tests/test_manager_security.py b/lark_channel/core/token/tests/test_manager_security.py
new file mode 100644
index 0000000..7cfbc63
--- /dev/null
+++ b/lark_channel/core/token/tests/test_manager_security.py
@@ -0,0 +1,203 @@
+import json
+import logging
+
+from lark_channel.channel.config import SecurityConfig
+from lark_channel.core.cache import ICache
+from lark_channel.core.http import Transport
+from lark_channel.core.model import Config, RawResponse
+from lark_channel.core.token.manager import TokenManager
+from lark_channel.event.security import (
+    InMemorySecurityAuditRecorder,
+    REASON_TOKEN_CACHE_LEGACY_FALLBACK,
+)
+
+
+class DictCache(ICache):
+    def __init__(self):
+        self.values = {}
+
+    def get(self, key: str):
+        return self.values.get(key)
+
+    def set(self, key: str, value: str, expire: int):
+        self.values[key] = value
+
+
+def _config(domain: str, security=None) -> Config:
+    config = Config()
+    config.app_id = "cli_same"
+    config.app_secret = "secret"
+    config.domain = domain
+    if security is not None:
+        config.security = security
+    return config
+
+
+def _token_response(token_suffix: str) -> RawResponse:
+    raw = RawResponse()
+    raw.status_code = 200
+    raw.content = json.dumps(
+        {
+            "code": 0,
+            "msg": "ok",
+            "tenant_access_token": f"tenant-{token_suffix}",
+            "app_access_token": f"app-{token_suffix}",
+            "expire": 7200,
+        }
+    ).encode("utf-8")
+    return raw
+
+
+def test_self_tenant_token_cache_is_isolated_by_domain(monkeypatch):
+    cache = DictCache()
+    monkeypatch.setattr(TokenManager, "cache", cache)
+    calls = []
+
+    def execute(config, request):
+        calls.append(config.domain)
+        return _token_response(config.domain.rsplit("/", 1)[-1])
+
+    monkeypatch.setattr(Transport, "execute", execute)
+
+    cn_token = TokenManager.get_self_tenant_token(
+        _config("https://open.feishu.cn")
+    )
+    global_token = TokenManager.get_self_tenant_token(
+        _config("https://open.larksuite.com")
+    )
+
+    assert cn_token == "tenant-open.feishu.cn"
+    assert global_token == "tenant-open.larksuite.com"
+    assert calls == ["https://open.feishu.cn", "https://open.larksuite.com"]
+
+
+def test_isv_tenant_token_cache_is_isolated_by_domain(monkeypatch):
+    cache = DictCache()
+    monkeypatch.setattr(TokenManager, "cache", cache)
+    calls = []
+
+    def execute(config, request):
+        calls.append(config.domain)
+        return _token_response(config.domain.rsplit("/", 1)[-1])
+
+    monkeypatch.setattr(Transport, "execute", execute)
+
+    cn_token = TokenManager.get_isv_tenant_token(
+        _config("https://open.feishu.cn"),
+        tenant_key="tenant_a",
+        app_ticket="ticket",
+    )
+    global_token = TokenManager.get_isv_tenant_token(
+        _config("https://open.larksuite.com"),
+        tenant_key="tenant_a",
+        app_ticket="ticket",
+    )
+
+    assert cn_token == "tenant-open.feishu.cn"
+    assert global_token == "tenant-open.larksuite.com"
+    assert calls == [
+        "https://open.feishu.cn",
+        "https://open.feishu.cn",
+        "https://open.larksuite.com",
+        "https://open.larksuite.com",
+    ]
+
+
+def test_compat_mode_reads_legacy_token_cache_key_and_records_audit(monkeypatch):
+    cache = DictCache()
+    cache.values["self_tenant_token:cli_same"] = "legacy-token"
+    monkeypatch.setattr(TokenManager, "cache", cache)
+    monkeypatch.setattr(
+        Transport,
+        "execute",
+        lambda config, request: (_ for _ in ()).throw(AssertionError("network called")),
+    )
+    recorder = InMemorySecurityAuditRecorder()
+
+    token = TokenManager.get_self_tenant_token(
+        _config(
+            "https://open.feishu.cn",
+            security=SecurityConfig(mode="compat", audit_recorder=recorder),
+        )
+    )
+
+    assert token == "legacy-token"
+    assert recorder.events[0].reason == REASON_TOKEN_CACHE_LEGACY_FALLBACK
+    assert recorder.events[0].mode == "compat"
+    assert recorder.events[0].action == "fallback"
+
+
+def test_default_compat_reads_legacy_token_cache_without_audit_warning(
+    monkeypatch,
+    caplog,
+):
+    cache = DictCache()
+    cache.values["self_tenant_token:cli_same"] = "legacy-token"
+    monkeypatch.setattr(TokenManager, "cache", cache)
+    monkeypatch.setattr(
+        Transport,
+        "execute",
+        lambda config, request: (_ for _ in ()).throw(AssertionError("network called")),
+    )
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        token = TokenManager.get_self_tenant_token(
+            _config(
+                "https://open.feishu.cn",
+                security=SecurityConfig(mode="compat"),
+            )
+        )
+
+    assert token == "legacy-token"
+    assert "security audit" not in caplog.text
+
+
+def test_legacy_token_cache_fallback_can_be_disabled(monkeypatch):
+    cache = DictCache()
+    cache.values["self_tenant_token:cli_same"] = "legacy-token"
+    monkeypatch.setattr(TokenManager, "cache", cache)
+    calls = []
+
+    def execute(config, request):
+        calls.append(config.domain)
+        return _token_response("fresh")
+
+    monkeypatch.setattr(Transport, "execute", execute)
+
+    token = TokenManager.get_self_tenant_token(
+        _config(
+            "https://open.feishu.cn",
+            security=SecurityConfig(
+                mode="compat",
+                legacy_token_cache_fallback=False,
+            ),
+        )
+    )
+
+    assert token == "tenant-fresh"
+    assert calls == ["https://open.feishu.cn"]
+
+
+def test_strict_mode_does_not_read_legacy_token_cache_key_by_default(monkeypatch):
+    cache = DictCache()
+    cache.values["self_tenant_token:cli_same"] = "legacy-token"
+    monkeypatch.setattr(TokenManager, "cache", cache)
+    calls = []
+
+    def execute(config, request):
+        calls.append(config.domain)
+        return _token_response("strict-fresh")
+
+    monkeypatch.setattr(Transport, "execute", execute)
+    recorder = InMemorySecurityAuditRecorder()
+
+    token = TokenManager.get_self_tenant_token(
+        _config(
+            "https://open.feishu.cn",
+            security=SecurityConfig(mode="strict", audit_recorder=recorder),
+        )
+    )
+
+    assert token == "tenant-strict-fresh"
+    assert calls == ["https://open.feishu.cn"]
+    assert recorder.events == []
diff --git a/lark_channel/core/type.py b/lark_channel/core/type.py
new file mode 100644
index 0000000..853073b
--- /dev/null
+++ b/lark_channel/core/type.py
@@ -0,0 +1,3 @@
+from typing import TypeVar
+
+T = TypeVar('T')
diff --git a/lark_channel/core/utils/__init__.py b/lark_channel/core/utils/__init__.py
new file mode 100644
index 0000000..c897db6
--- /dev/null
+++ b/lark_channel/core/utils/__init__.py
@@ -0,0 +1,4 @@
+from .decryptor import *
+from .files import *
+from .strings import *
+from .user_agent import build_user_agent, sanitize_source
diff --git a/lark_channel/core/utils/decryptor.py b/lark_channel/core/utils/decryptor.py
new file mode 100644
index 0000000..adb188d
--- /dev/null
+++ b/lark_channel/core/utils/decryptor.py
@@ -0,0 +1,33 @@
+import base64
+import hashlib
+from typing import Union
+
+from Crypto.Cipher import AES
+
+from ..const import UTF_8
+
+
+class AESCipher(object):
+    def __init__(self, key: Union[str, bytes]) -> None:
+        if isinstance(key, str):
+            key = key.encode(UTF_8)
+        self.digest = hashlib.sha256(key).digest()
+
+    def decrypt(self, enc: bytes) -> bytes:
+        if len(enc) < AES.block_size * 2 or len(enc) % AES.block_size != 0:
+            raise ValueError("invalid ciphertext length")
+        iv = enc[: AES.block_size]
+        cipher = AES.new(self.digest, AES.MODE_CBC, iv)
+        s = cipher.decrypt(enc[AES.block_size:])
+        if not s:
+            raise ValueError("invalid ciphertext: empty plaintext")
+        pad = s[-1]
+        if pad < 1 or pad > AES.block_size or pad > len(s):
+            raise ValueError("invalid PKCS7 padding")
+        if s[-pad:] != bytes([pad]) * pad:
+            raise ValueError("invalid PKCS7 padding")
+        return s[:-pad]
+
+    def decrypt_str(self, enc: str) -> str:
+        enc = base64.b64decode(enc)
+        return self.decrypt(enc).decode(UTF_8)
diff --git a/lark_channel/core/utils/files.py b/lark_channel/core/utils/files.py
new file mode 100644
index 0000000..50a8a21
--- /dev/null
+++ b/lark_channel/core/utils/files.py
@@ -0,0 +1,79 @@
+import io
+from email.utils import decode_rfc2231
+from typing import Any, Dict, Optional
+from urllib.parse import unquote
+
+from lark_channel.core import Content_Disposition
+
+
+class Files(object):
+    @staticmethod
+    def parse_file_name(headers: Dict[str, str]) -> Optional[str]:
+        content_disposition = headers.get(Content_Disposition)
+        if content_disposition is None:
+            return None
+
+        parts = content_disposition.split(';')
+        params = {}
+
+        for part in parts:
+            if '=' in part:
+                k, v = part.strip().split('=', 1)
+                params[k] = v.strip(' "')
+
+        if 'filename*' in params:
+            # Decode RFC2231 encoded format
+            filename = decode_rfc2231(params['filename*'])[2]
+            filename = unquote(filename)
+        elif 'filename' in params:
+            # Handle possible encoding issues with a basic unquote
+            filename = unquote(params['filename'])
+            # or try to decode using utf-8 if it seems like a valid utf-8 string
+            try:
+                filename = filename.encode('latin1').decode('utf-8')
+            except (UnicodeEncodeError, UnicodeDecodeError):
+                pass
+        else:
+            filename = None
+
+        return filename
+
+    @staticmethod
+    def parse_form_data(obj: Any) -> Dict[str, Any]:
+        fd = {}
+        if isinstance(obj, dict):
+            fd = obj
+        elif not hasattr(obj, "__dict__"):
+            return fd
+        else:
+            fd = vars(obj)
+
+        for k, v in fd.items():
+            if v is None or isinstance(v, io.IOBase) or isinstance(v, tuple):
+                continue
+            fd[k] = str(v)
+
+        return fd
+
+    @staticmethod
+    def extract_files(obj: Any):
+        if obj is None:
+            return None
+        files = {}
+        if isinstance(obj, dict):
+            to_del_keys = []
+            for k, v in obj.items():
+                if isinstance(v, io.IOBase):
+                    files[k] = v
+                    to_del_keys.append(k)
+            for k in to_del_keys:
+                del obj[k]
+        elif not hasattr(obj, "__dict__"):
+            return None
+        else:
+            for k, v in vars(obj).items():
+                if isinstance(v, io.IOBase):
+                    files[k] = v
+                    setattr(obj, k, None)
+
+        return files
diff --git a/lark_channel/core/utils/strings.py b/lark_channel/core/utils/strings.py
new file mode 100644
index 0000000..4238fe7
--- /dev/null
+++ b/lark_channel/core/utils/strings.py
@@ -0,0 +1,12 @@
+from typing import Optional
+
+
+class Strings(object):
+
+    @staticmethod
+    def is_not_empty(s: Optional[str]) -> bool:
+        return not Strings.is_empty(s)
+
+    @staticmethod
+    def is_empty(s: Optional[str]) -> bool:
+        return s is None or len(s) == 0
diff --git a/lark_channel/core/utils/user_agent.py b/lark_channel/core/utils/user_agent.py
new file mode 100644
index 0000000..321090b
--- /dev/null
+++ b/lark_channel/core/utils/user_agent.py
@@ -0,0 +1,49 @@
+"""User-Agent construction.
+
+Mirrors node-sdk's `buildUserAgent`: returns the base SDK token, optionally
+appends a sanitized ``source/<name>`` product token, and finally appends any
+sub-module supplied bare tokens (e.g. ``channel``).
+"""
+
+import re
+from typing import Iterable, Optional
+
+from lark_channel.core.const import PROJECT, VERSION
+
+_SANITIZE_RE = re.compile(r"[^a-zA-Z0-9._-]")
+
+
+def sanitize_source(raw: str) -> str:
+    """Replace non-token characters with ``_`` and clamp length to 64.
+
+    Returns an empty string when ``raw`` is falsy or sanitizes to nothing.
+    """
+    if not raw:
+        return ""
+    return _SANITIZE_RE.sub("_", raw)[:64]
+
+
+def build_user_agent(
+    source: Optional[str] = None,
+    extra_tags: Optional[Iterable[str]] = None,
+) -> str:
+    """Build the User-Agent string.
+
+    Format::
+
+        channel-sdk-python/v<version>[ source/<sanitized>][ <tag>...]
+
+    ``extra_tags`` is internal — sub-modules (e.g. channel) use it to mark
+    requests they originate.
+    """
+    ua = f"{PROJECT}/v{VERSION}"
+    if source:
+        clean = sanitize_source(source)
+        if clean:
+            ua += f" source/{clean}"
+    if extra_tags:
+        for tag in extra_tags:
+            clean = sanitize_source(tag)
+            if clean:
+                ua += f" {clean}"
+    return ua
diff --git a/lark_channel/event/__init__.py b/lark_channel/event/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/lark_channel/event/callback/__init__.py b/lark_channel/event/callback/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/lark_channel/event/callback/model/__init__.py b/lark_channel/event/callback/model/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/lark_channel/event/callback/model/p2_card_action_trigger.py b/lark_channel/event/callback/model/p2_card_action_trigger.py
new file mode 100644
index 0000000..8343fe3
--- /dev/null
+++ b/lark_channel/event/callback/model/p2_card_action_trigger.py
@@ -0,0 +1,131 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.event.context import EventContext
+
+
+class CallBackOperator(object):
+    _types = {
+        "tenant_key": str,
+        "user_id": str,
+        "open_id": str,
+        "union_id": str,
+    }
+
+    def __init__(self, d=None):
+        self.tenant_key: Optional[str] = None
+        self.user_id: Optional[str] = None
+        self.open_id: Optional[str] = None
+        self.union_id: Optional[str] = None
+        init(self, d, self._types)
+
+
+class CallBackContext(object):
+    _types = {
+        "url": str,
+        "preview_token": str,
+        "open_message_id": str,
+        "open_chat_id": str,
+    }
+
+    def __init__(self, d=None):
+        self.url: Optional[str] = None
+        self.preview_token: Optional[str] = None
+        self.open_message_id: Optional[str] = None
+        self.open_chat_id: Optional[str] = None
+        init(self, d, self._types)
+
+
+class CallBackAction(object):
+    _types = {
+        "value": Dict[str, Any],
+        "tag": str,
+        "option": str,
+        "timezone": str,
+        "name": str,
+        "form_value": Dict[str, Any],
+        "input_value": str,
+        "options": List[str],
+        "checked": bool,
+    }
+
+    def __init__(self, d=None):
+        self.value: Optional[Dict[str, Any]] = None
+        self.tag: Optional[str] = None
+        self.option: Optional[str] = None
+        self.timezone: Optional[str] = None
+        self.name: Optional[str] = None
+        self.form_value: Optional[Dict[str, Any]] = None
+        self.input_value: Optional[str] = None
+        self.options: Optional[List[str]] = None
+        self.checked: Optional[bool] = None
+        init(self, d, self._types)
+
+
+class P2CardActionTriggerData(object):
+    _types = {
+        "operator": CallBackOperator,
+        "token": str,
+        "action": CallBackAction,
+        "host": str,
+        "delivery_type": str,
+        "context": CallBackContext,
+    }
+
+    def __init__(self, d=None):
+        self.operator: Optional[CallBackOperator] = None
+        self.token: Optional[str] = None
+        self.action: Optional[CallBackAction] = None
+        self.host: Optional[str] = None
+        self.delivery_type: Optional[str] = None
+        self.context: Optional[CallBackContext] = None
+        init(self, d, self._types)
+
+
+class P2CardActionTrigger(EventContext):
+    _types = {
+        "event": P2CardActionTriggerData
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self._types.update(super()._types)
+        self.event: Optional[P2CardActionTriggerData] = None
+        init(self, d, self._types)
+
+
+class CallBackToast(object):
+    _types = {
+        "type": str,
+        "content": str,
+        "i18n": Dict[str, str],
+    }
+
+    def __init__(self, d=None):
+        self.type: Optional[str] = None
+        self.content: Optional[str] = None
+        self.i18n: Optional[Dict[str, str]] = None
+        init(self, d, self._types)
+
+
+class CallBackCard(object):
+    _types = {
+        "type": str,
+        "data": Any,
+    }
+
+    def __init__(self, d=None):
+        self.type: Optional[str] = None
+        self.data: Optional[Any] = None
+        init(self, d, self._types)
+
+
+class P2CardActionTriggerResponse(object):
+    _types = {
+        "toast": CallBackToast,
+        "card": CallBackCard,
+    }
+
+    def __init__(self, d=None):
+        self.toast: Optional[CallBackToast] = None
+        self.card: Optional[CallBackCard] = None
+        init(self, d, self._types)
diff --git a/lark_channel/event/callback/model/p2_url_preview_get.py b/lark_channel/event/callback/model/p2_url_preview_get.py
new file mode 100644
index 0000000..c3186a7
--- /dev/null
+++ b/lark_channel/event/callback/model/p2_url_preview_get.py
@@ -0,0 +1,76 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+from lark_channel.core.construct import init
+from lark_channel.event.context import EventContext
+from lark_channel.event.callback.model.p2_card_action_trigger import CallBackOperator, CallBackContext, CallBackCard
+
+
+class P2URLPreviewGetData(object):
+    _types = {
+        "operator": CallBackOperator,
+        "host": str,
+        "context": CallBackContext,
+    }
+
+    def __init__(self, d=None):
+        self.operator: Optional[CallBackOperator] = None
+        self.host: Optional[str] = None
+        self.context: Optional[CallBackContext] = None
+        init(self, d, self._types)
+
+
+class P2URLPreviewGet(EventContext):
+    _types = {
+        "event": P2URLPreviewGetData,
+    }
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self._types.update(super()._types)
+        self.event: Optional[P2URLPreviewGetData] = None
+        init(self, d, self._types)
+
+
+class URLPreviewGetInlineURL(object):
+    _types = {
+        "copy_url": str,
+        "ios": str,
+        "android": str,
+        "pc": str,
+        "web": str,
+    }
+
+    def __init__(self, d=None):
+        self.copy_url: Optional[str] = None
+        self.ios: Optional[str] = None
+        self.android: Optional[str] = None
+        self.pc: Optional[str] = None
+        self.web: Optional[str] = None
+        init(self, d, self._types)
+
+
+class URLPreviewGetInline(object):
+    _types = {
+        "title": str,
+        "i18n_title": Dict[str, str],
+        "image_key": str,
+        "url": URLPreviewGetInlineURL,
+    }
+
+    def __init__(self, d=None):
+        self.title: Optional[str] = None
+        self.i18n_title: Optional[Dict[str, str]] = None
+        self.image_key: Optional[str] = None
+        self.url: Optional[URLPreviewGetInlineURL] = None
+        init(self, d, self._types)
+
+
+class P2URLPreviewGetResponse(object):
+    _types = {
+        "inline": URLPreviewGetInline,
+        "card": CallBackCard,
+    }
+
+    def __init__(self, d=None):
+        self.inline: Optional[URLPreviewGetInline] = None
+        self.card: Optional[CallBackCard] = None
+        init(self, d, self._types)
diff --git a/lark_channel/event/callback/processor.py b/lark_channel/event/callback/processor.py
new file mode 100644
index 0000000..f6a6313
--- /dev/null
+++ b/lark_channel/event/callback/processor.py
@@ -0,0 +1,27 @@
+from typing import Any, Optional, Union, Dict, List, Set, IO, Callable, Type
+
+from lark_channel.event.processor import ICallBackProcessor
+from .model.p2_card_action_trigger import P2CardActionTrigger, P2CardActionTriggerResponse
+from .model.p2_url_preview_get import P2URLPreviewGet, P2URLPreviewGetResponse
+
+
+class P2CardActionTriggerProcessor(ICallBackProcessor[P2CardActionTrigger]):
+    def __init__(self, f: Callable[[P2CardActionTrigger], P2CardActionTriggerResponse]):
+        self.f = f
+
+    def type(self) -> Type[P2CardActionTrigger]:
+        return P2CardActionTrigger
+
+    def do(self, data: P2CardActionTrigger) -> P2CardActionTriggerResponse:
+        return self.f(data)
+
+
+class P2URLPreviewGetProcessor(ICallBackProcessor[P2URLPreviewGet]):
+    def __init__(self, f: Callable[[P2URLPreviewGet], P2URLPreviewGetResponse]):
+        self.f = f
+
+    def type(self) -> Type[P2URLPreviewGet]:
+        return P2URLPreviewGet
+
+    def do(self, data: P2URLPreviewGet) -> P2URLPreviewGetResponse:
+        return self.f(data)
diff --git a/lark_channel/event/context.py b/lark_channel/event/context.py
new file mode 100644
index 0000000..dbc1c7c
--- /dev/null
+++ b/lark_channel/event/context.py
@@ -0,0 +1,33 @@
+from typing import *
+
+from lark_channel.core.construct import init
+
+
+class EventHeader(object):
+    _types = {}
+
+    def __init__(self, d=None) -> None:
+        self.event_id: Optional[str] = None
+        self.token: Optional[str] = None
+        self.create_time: Optional[str] = None
+        self.event_type: Optional[str] = None
+        self.tenant_key: Optional[str] = None
+        self.app_id: Optional[str] = None
+        init(self, d, self._types)
+
+
+class EventContext(object):
+    _types = {
+        "header": EventHeader
+    }
+
+    def __init__(self, d=None) -> None:
+        self.challenge: Optional[str] = None  # deprecated
+        self.ts: Optional[str] = None  # p1 only
+        self.uuid: Optional[str] = None  # p1 only
+        self.token: Optional[str] = None  # p1 only
+        self.type: Optional[str] = None  # p1 only
+        self.schema: Optional[str] = None  # p2 only
+        self.header: Optional[EventHeader] = None  # p2 only
+        self.event: Dict = {}
+        init(self, d, self._types)
diff --git a/lark_channel/event/custom.py b/lark_channel/event/custom.py
new file mode 100644
index 0000000..f96e259
--- /dev/null
+++ b/lark_channel/event/custom.py
@@ -0,0 +1,26 @@
+from typing import *
+
+from lark_channel.core.construct import init
+from .context import EventContext
+from .processor import IEventProcessor
+
+
+class CustomizedEvent(EventContext):
+    _types = {}
+
+    def __init__(self, d=None):
+        super().__init__(d)
+        self._types.update(super()._types)
+        self.event: Optional[Dict] = None
+        init(self, d, self._types)
+
+
+class CustomizedEventProcessor(IEventProcessor[CustomizedEvent]):
+    def __init__(self, f: Callable[[CustomizedEvent], None]):
+        self.f = f
+
+    def type(self) -> Type[CustomizedEvent]:
+        return CustomizedEvent
+
+    def do(self, data: CustomizedEvent) -> None:
+        self.f(data)
diff --git a/lark_channel/event/dispatcher_handler.py b/lark_channel/event/dispatcher_handler.py
new file mode 100644
index 0000000..b06f7d7
--- /dev/null
+++ b/lark_channel/event/dispatcher_handler.py
@@ -0,0 +1,425 @@
+import hashlib
+import hmac
+import json
+import logging
+import warnings
+from typing import Any, Callable, Dict, Optional, TYPE_CHECKING, Type
+
+from lark_channel.api.im.v1.processor import (
+    P2ImChatMemberBotAddedV1Processor,
+    P2ImChatMemberBotDeletedV1Processor,
+    P2ImMessageMessageReadV1Processor,
+    P2ImMessageReactionCreatedV1Processor,
+    P2ImMessageReactionDeletedV1Processor,
+    P2ImMessageReceiveV1Processor,
+)
+from lark_channel.api.im.v1.model.p2_im_chat_member_bot_added_v1 import (
+    P2ImChatMemberBotAddedV1,
+)
+from lark_channel.api.im.v1.model.p2_im_chat_member_bot_deleted_v1 import (
+    P2ImChatMemberBotDeletedV1,
+)
+from lark_channel.api.im.v1.model.p2_im_message_message_read_v1 import (
+    P2ImMessageMessageReadV1,
+)
+from lark_channel.api.im.v1.model.p2_im_message_reaction_created_v1 import (
+    P2ImMessageReactionCreatedV1,
+)
+from lark_channel.api.im.v1.model.p2_im_message_reaction_deleted_v1 import (
+    P2ImMessageReactionDeletedV1,
+)
+from lark_channel.api.im.v1.model.p2_im_message_receive_v1 import (
+    P2ImMessageReceiveV1,
+)
+from lark_channel.core.const import (
+    APPLICATION_JSON,
+    LARK_REQUEST_NONCE,
+    LARK_REQUEST_SIGNATURE,
+    LARK_REQUEST_TIMESTAMP,
+    UTF_8,
+    URL_VERIFICATION,
+    X_REQUEST_ID,
+)
+from lark_channel.core.enum import LogLevel
+from lark_channel.core.exception import (
+    AccessDeniedException,
+    EventException,
+    InvalidArgsException,
+    NoAuthorizationException,
+)
+from lark_channel.core.http import HttpHandler
+from lark_channel.core.json import JSON
+from lark_channel.core.log import logger, redact_for_log
+from lark_channel.core.model import RawRequest, RawResponse
+from lark_channel.core.utils import AESCipher, Strings
+from .callback.model.p2_card_action_trigger import (
+    P2CardActionTrigger,
+    P2CardActionTriggerResponse,
+)
+from .callback.model.p2_url_preview_get import (
+    P2URLPreviewGet,
+    P2URLPreviewGetResponse,
+)
+from .callback.processor import (
+    P2CardActionTriggerProcessor,
+    P2URLPreviewGetProcessor,
+)
+from .context import EventContext
+from .custom import CustomizedEvent, CustomizedEventProcessor
+from .processor import ICallBackProcessor, IEventProcessor
+from .security import (
+    REASON_WEBHOOK_SIGNATURE_INVALID,
+    REASON_WEBHOOK_SIGNATURE_MISSING,
+    build_error_response_content,
+    should_record_security_audit,
+)
+
+if TYPE_CHECKING:
+    from lark_channel.channel.config import SecurityConfig
+
+
+class EventDispatcherHandler(HttpHandler):
+    def __init__(self, security: Optional["SecurityConfig"] = None) -> None:
+        self._processorMap: Dict[str, IEventProcessor] = {}
+        self._callback_processor_map: Dict[str, ICallBackProcessor] = {}
+        self._encrypt_key: Optional[str] = None
+        self._verification_token: Optional[str] = None
+        self._security = security or _default_security_config()
+
+    def do(self, req: RawRequest) -> RawResponse:
+        if logger.isEnabledFor(logging.DEBUG):
+            logger.debug(
+                "event access, uri: %s, headers: %s, body: %s",
+                req.uri,
+                JSON.marshal(redact_for_log(req.headers)),
+                JSON.marshal(redact_for_log(req.body)) if req.body is not None else None,
+            )
+
+        resp = RawResponse()
+        resp.status_code = 200
+        resp.set_content_type(f"{APPLICATION_JSON}; charset=utf-8")
+
+        try:
+            if req.body is None:
+                raise InvalidArgsException("request body is null")
+
+            signature_preverified = False
+            if self._is_encrypted_payload(req.body):
+                signature_preverified = self._preverify_encrypted_request(req)
+
+            plaintext = self._decrypt(req.body)
+            context = self._parse_context(plaintext)
+
+            if Strings.is_not_empty(self._verification_token):
+                if context.token is None or not hmac.compare_digest(
+                    self._verification_token, context.token
+                ):
+                    raise AccessDeniedException("invalid verification_token")
+
+            if URL_VERIFICATION == context.type:
+                resp.content = JSON.marshal({"challenge": context.challenge}).encode(
+                    UTF_8
+                )
+                return resp
+
+            if not signature_preverified:
+                self._verify_sign(req)
+            result = self._dispatch(plaintext, context)
+            if result is _NO_CALLBACK_RESULT:
+                resp.content = b'{"msg":"success"}'
+            else:
+                resp.content = JSON.marshal(result).encode(UTF_8)
+            return resp
+
+        except Exception as e:
+            if self._security.enforce_strict_error_response:
+                logger.error(
+                    "handle event failed, uri: %s, request_id: %s, err: %s",
+                    req.uri,
+                    req.headers.get(X_REQUEST_ID),
+                    redact_for_log(str(e)),
+                )
+            else:
+                logger.exception(
+                    "handle event failed, uri: %s, request_id: %s, err: %s",
+                    req.uri,
+                    req.headers.get(X_REQUEST_ID),
+                    e,
+                )
+            resp.status_code = 500
+            resp.content = build_error_response_content(e, security=self._security)
+            return resp
+
+    def _do_without_validation(self, payload: bytes) -> Any:
+        plaintext = payload.decode(UTF_8)
+        context = self._parse_context(plaintext)
+        result = self._dispatch(plaintext, context)
+        if result is _NO_CALLBACK_RESULT:
+            return None
+        return result
+
+    def do_without_validation(self, payload: bytes) -> Any:
+        warnings.warn(
+            "EventDispatcherHandler.do_without_validation() is deprecated and "
+            "kept only for backward compatibility. Use do(req) for HTTP "
+            "callbacks; WebSocket dispatch is handled internally by the SDK.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self._do_without_validation(payload)
+
+    def _decrypt(self, content: bytes) -> str:
+        encrypt = json.loads(content).get("encrypt")
+        if Strings.is_not_empty(encrypt):
+            if Strings.is_empty(self._encrypt_key):
+                raise NoAuthorizationException("encrypt_key not found")
+            return AESCipher(self._encrypt_key).decrypt_str(encrypt)
+        return str(content, UTF_8)
+
+    def _is_encrypted_payload(self, content: bytes) -> bool:
+        try:
+            encrypt = json.loads(content).get("encrypt")
+        except (TypeError, ValueError, AttributeError):
+            return False
+        return Strings.is_not_empty(encrypt)
+
+    def _preverify_encrypted_request(self, request: RawRequest) -> bool:
+        if Strings.is_empty(self._encrypt_key):
+            return False
+        if not self._has_signature_headers(request):
+            action = "legacy_flow"
+            if self._security.is_strict:
+                action = (
+                    "allow"
+                    if self._security.allow_unsigned_encrypted_webhook
+                    else "block"
+                )
+            self._record_security_audit(
+                REASON_WEBHOOK_SIGNATURE_MISSING,
+                action=action,
+                request=request,
+            )
+            if (
+                self._security.is_strict
+                and not self._security.allow_unsigned_encrypted_webhook
+            ):
+                raise AccessDeniedException("signature verification failed")
+            return True
+        try:
+            self._verify_sign(request)
+        except Exception:
+            self._record_security_audit(
+                REASON_WEBHOOK_SIGNATURE_INVALID,
+                action="block",
+                request=request,
+            )
+            raise
+        return True
+
+    def _has_signature_headers(self, request: RawRequest) -> bool:
+        return (
+            Strings.is_not_empty(request.headers.get(LARK_REQUEST_TIMESTAMP))
+            and Strings.is_not_empty(request.headers.get(LARK_REQUEST_NONCE))
+            and Strings.is_not_empty(request.headers.get(LARK_REQUEST_SIGNATURE))
+        )
+
+    def _record_security_audit(
+        self,
+        reason: str,
+        *,
+        action: str,
+        request: RawRequest,
+    ) -> None:
+        if not should_record_security_audit(self._security):
+            return
+        self._security.audit_recorder.record(
+            reason,
+            mode=self._security.mode,
+            action=action,
+            details={
+                "uri": request.uri,
+                "request_id": request.headers.get(X_REQUEST_ID),
+            },
+        )
+
+    def _verify_sign(self, request: RawRequest) -> None:
+        if self._encrypt_key is None or self._encrypt_key == "":
+            return
+        timestamp = request.headers.get(LARK_REQUEST_TIMESTAMP)
+        nonce = request.headers.get(LARK_REQUEST_NONCE)
+        signature = request.headers.get(LARK_REQUEST_SIGNATURE)
+        bs = (timestamp + nonce + self._encrypt_key).encode(UTF_8) + request.body
+        if signature != hashlib.sha256(bs).hexdigest():
+            raise AccessDeniedException("signature verification failed")
+
+    def _parse_context(self, plaintext: str) -> EventContext:
+        context = JSON.unmarshal(plaintext, EventContext)
+        if Strings.is_not_empty(context.schema):
+            context.schema = "p2"
+            context.type = context.header.event_type
+            context.token = context.header.token
+        elif Strings.is_not_empty(context.uuid):
+            context.schema = "p1"
+            context.type = context.event.get("type")
+        return context
+
+    def _dispatch(self, plaintext: str, context: EventContext) -> Any:
+        event_key = f"{context.schema}.{context.type}"
+        if event_key in self._callback_processor_map:
+            processor = self._callback_processor_map.get(event_key)
+            if processor is None:
+                raise EventException(f"callback processor not found, type: {context.type}")
+            data = JSON.unmarshal(plaintext, processor.type())
+            return processor.do(data)
+
+        processor = self._processorMap.get(event_key)
+        if processor is None:
+            raise EventException(f"processor not found, type: {context.type}")
+        data = JSON.unmarshal(plaintext, processor.type())
+        processor.do(data)
+        return _NO_CALLBACK_RESULT
+
+    @staticmethod
+    def builder(
+        encrypt_key: str,
+        verification_token: str,
+        level: LogLevel = None,
+        *,
+        security: Optional["SecurityConfig"] = None,
+    ) -> "EventDispatcherHandlerBuilder":
+        if level is not None:
+            logger.setLevel(int(level.value))
+        return EventDispatcherHandlerBuilder(
+            encrypt_key,
+            verification_token,
+            security=security,
+        )
+
+
+class _NoCallbackResult:
+    pass
+
+
+_NO_CALLBACK_RESULT = _NoCallbackResult()
+
+
+class EventDispatcherHandlerBuilder(object):
+    def __init__(
+        self,
+        encrypt_key: str,
+        verification_token: str,
+        *,
+        security: Optional["SecurityConfig"] = None,
+    ) -> None:
+        self._encrypt_key = encrypt_key
+        self._verification_token = verification_token
+        self._security = security or _default_security_config()
+        self._processorMap: Dict[str, IEventProcessor] = {}
+        self._callback_processor_map: Dict[str, ICallBackProcessor] = {}
+
+    def register_p1_customized_event(
+        self, event_type: str, f: Callable[[CustomizedEvent], None]
+    ) -> "EventDispatcherHandlerBuilder":
+        return self._register_event(
+            f"p1.{event_type}", CustomizedEventProcessor(f)
+        )
+
+    def register_p2_customized_event(
+        self, event_type: str, f: Callable[[CustomizedEvent], None]
+    ) -> "EventDispatcherHandlerBuilder":
+        return self._register_event(
+            f"p2.{event_type}", CustomizedEventProcessor(f)
+        )
+
+    def register_p2_card_action_trigger(
+        self,
+        f: Callable[[P2CardActionTrigger], P2CardActionTriggerResponse],
+    ) -> "EventDispatcherHandlerBuilder":
+        return self._register_callback(
+            "p2.card.action.trigger", P2CardActionTriggerProcessor(f)
+        )
+
+    def register_p2_url_preview_get(
+        self,
+        f: Callable[[P2URLPreviewGet], P2URLPreviewGetResponse],
+    ) -> "EventDispatcherHandlerBuilder":
+        return self._register_callback(
+            "p2.url.preview.get", P2URLPreviewGetProcessor(f)
+        )
+
+    def register_p2_im_message_receive_v1(
+        self, f: Callable[[P2ImMessageReceiveV1], None]
+    ) -> "EventDispatcherHandlerBuilder":
+        return self._register_event(
+            "p2.im.message.receive_v1", P2ImMessageReceiveV1Processor(f)
+        )
+
+    def register_p2_im_message_reaction_created_v1(
+        self, f: Callable[[P2ImMessageReactionCreatedV1], None]
+    ) -> "EventDispatcherHandlerBuilder":
+        return self._register_event(
+            "p2.im.message.reaction.created_v1",
+            P2ImMessageReactionCreatedV1Processor(f),
+        )
+
+    def register_p2_im_message_reaction_deleted_v1(
+        self, f: Callable[[P2ImMessageReactionDeletedV1], None]
+    ) -> "EventDispatcherHandlerBuilder":
+        return self._register_event(
+            "p2.im.message.reaction.deleted_v1",
+            P2ImMessageReactionDeletedV1Processor(f),
+        )
+
+    def register_p2_im_chat_member_bot_added_v1(
+        self, f: Callable[[P2ImChatMemberBotAddedV1], None]
+    ) -> "EventDispatcherHandlerBuilder":
+        return self._register_event(
+            "p2.im.chat.member.bot.added_v1",
+            P2ImChatMemberBotAddedV1Processor(f),
+        )
+
+    def register_p2_im_chat_member_bot_deleted_v1(
+        self, f: Callable[[P2ImChatMemberBotDeletedV1], None]
+    ) -> "EventDispatcherHandlerBuilder":
+        return self._register_event(
+            "p2.im.chat.member.bot.deleted_v1",
+            P2ImChatMemberBotDeletedV1Processor(f),
+        )
+
+    def register_p2_im_message_message_read_v1(
+        self, f: Callable[[P2ImMessageMessageReadV1], None]
+    ) -> "EventDispatcherHandlerBuilder":
+        return self._register_event(
+            "p2.im.message.message_read_v1",
+            P2ImMessageMessageReadV1Processor(f),
+        )
+
+    def _register_event(
+        self, key: str, processor: IEventProcessor
+    ) -> "EventDispatcherHandlerBuilder":
+        if key in self._processorMap:
+            raise EventException(f"processor already registered, type: {key}")
+        self._processorMap[key] = processor
+        return self
+
+    def _register_callback(
+        self, key: str, processor: ICallBackProcessor
+    ) -> "EventDispatcherHandlerBuilder":
+        if key in self._callback_processor_map:
+            raise EventException(f"processor already registered, type: {key}")
+        self._callback_processor_map[key] = processor
+        return self
+
+    def build(self) -> EventDispatcherHandler:
+        handler = EventDispatcherHandler(security=self._security)
+        handler._encrypt_key = self._encrypt_key
+        handler._verification_token = self._verification_token
+        handler._processorMap = self._processorMap
+        handler._callback_processor_map = self._callback_processor_map
+        return handler
+
+
+def _default_security_config():
+    from lark_channel.channel.config import SecurityConfig
+
+    return SecurityConfig()
diff --git a/lark_channel/event/processor.py b/lark_channel/event/processor.py
new file mode 100644
index 0000000..0492cb9
--- /dev/null
+++ b/lark_channel/event/processor.py
@@ -0,0 +1,24 @@
+from abc import ABC, abstractmethod
+from typing import *
+
+from lark_channel.core import T
+
+
+class IEventProcessor(ABC, Generic[T]):
+    @abstractmethod
+    def type(self) -> Type[T]:
+        pass
+
+    @abstractmethod
+    def do(self, data: T) -> None:
+        pass
+
+
+class ICallBackProcessor(ABC, Generic[T]):
+    @abstractmethod
+    def type(self) -> Type[T]:
+        pass
+
+    @abstractmethod
+    def do(self, data: T) -> Any:
+        pass
diff --git a/lark_channel/event/security.py b/lark_channel/event/security.py
new file mode 100644
index 0000000..68c1c21
--- /dev/null
+++ b/lark_channel/event/security.py
@@ -0,0 +1,632 @@
+from dataclasses import dataclass, field
+import json
+import re
+from typing import Any, Dict, List, Mapping, Optional, Set
+
+from lark_channel.core.const import UTF_8
+from lark_channel.core.json import JSON
+from lark_channel.core.log import logger
+
+REASON_WEBHOOK_SIGNATURE_MISSING = "webhook.signature_missing"
+REASON_WEBHOOK_SIGNATURE_INVALID = "webhook.signature_invalid"
+REASON_WEBHOOK_TOKEN_MISSING = "webhook.token_missing"
+REASON_WEBHOOK_TOKEN_INVALID = "webhook.token_invalid"
+REASON_WEBHOOK_DECRYPT_WITHOUT_VERIFIED_SIGNATURE = (
+    "webhook.decrypt_without_verified_signature"
+)
+REASON_WEBHOOK_DECRYPT_FAILED = "webhook.decrypt_failed"
+REASON_CARD_TOKEN_MISSING = "card.token_missing"
+REASON_CARD_TOKEN_INVALID = "card.token_invalid"
+REASON_CARD_SIGNATURE_MISSING = "card.signature_missing"
+REASON_CARD_SIGNATURE_INVALID = "card.signature_invalid"
+REASON_CARD_DECRYPT_FAILED = "card.decrypt_failed"
+REASON_WS_INSECURE_SCHEME = "ws.insecure_scheme"
+REASON_WS_INVALID_TIMING = "ws.invalid_timing"
+REASON_WS_FRAGMENT_LIMIT = "ws.fragment_limit"
+REASON_RESOURCE_LIMIT_WOULD_BLOCK = "resource.limit_would_block"
+REASON_MENTIONS_TEXT_ONLY = "mentions.text_only"
+REASON_CONTENT_TEXT_UNSAFE_LEGACY = "content_text.unsafe_legacy"
+REASON_TOKEN_CACHE_LEGACY_FALLBACK = "token_cache.legacy_fallback"
+
+
+@dataclass(frozen=True)
+class SecurityAuditEvent:
+    reason: str
+    mode: str
+    action: str
+    details: Dict[str, Any] = field(default_factory=dict)
+
+
+class SecurityAuditRecorder:
+    def __init__(
+        self,
+        *,
+        max_detail_chars: int = 4096,
+        max_detail_items: int = 50,
+        max_detail_total_chars: int = 16384,
+    ) -> None:
+        self._max_detail_chars = _validate_positive_int(
+            "max_detail_chars",
+            max_detail_chars,
+        )
+        self._max_detail_items = _validate_positive_int(
+            "max_detail_items",
+            max_detail_items,
+        )
+        self._max_detail_total_chars = _validate_positive_int(
+            "max_detail_total_chars",
+            max_detail_total_chars,
+        )
+
+    def record(
+        self,
+        reason: str,
+        *,
+        mode: str,
+        action: str,
+        details: Optional[Mapping[str, Any]] = None,
+    ) -> None:
+        safe_details = _redacted_details(
+            details,
+            max_string_chars=self._max_detail_chars,
+            max_items=self._max_detail_items,
+            max_total_chars=self._max_detail_total_chars,
+        )
+        safe_reason = _redacted_label(
+            reason,
+            max_string_chars=self._max_detail_chars,
+        )
+        safe_mode = _redacted_label(
+            mode,
+            max_string_chars=self._max_detail_chars,
+        )
+        safe_action = _redacted_label(
+            action,
+            max_string_chars=self._max_detail_chars,
+        )
+        logger.warning(
+            "security audit: reason=%s mode=%s action=%s details=%s",
+            safe_reason,
+            safe_mode,
+            safe_action,
+            JSON.marshal(safe_details),
+        )
+
+
+class InMemorySecurityAuditRecorder(SecurityAuditRecorder):
+    def __init__(
+        self,
+        *,
+        max_events: int = 1000,
+        max_detail_chars: int = 4096,
+        max_detail_items: int = 50,
+        max_detail_total_chars: int = 16384,
+    ) -> None:
+        super().__init__(
+            max_detail_chars=max_detail_chars,
+            max_detail_items=max_detail_items,
+            max_detail_total_chars=max_detail_total_chars,
+        )
+        self._max_events = _validate_positive_int("max_events", max_events)
+        self.events: List[SecurityAuditEvent] = []
+
+    def record(
+        self,
+        reason: str,
+        *,
+        mode: str,
+        action: str,
+        details: Optional[Mapping[str, Any]] = None,
+    ) -> None:
+        self.events.append(
+            SecurityAuditEvent(
+                reason=_redacted_label(
+                    reason,
+                    max_string_chars=self._max_detail_chars,
+                ),
+                mode=_redacted_label(
+                    mode,
+                    max_string_chars=self._max_detail_chars,
+                ),
+                action=_redacted_label(
+                    action,
+                    max_string_chars=self._max_detail_chars,
+                ),
+                details=_redacted_details(
+                    details,
+                    max_string_chars=self._max_detail_chars,
+                    max_items=self._max_detail_items,
+                    max_total_chars=self._max_detail_total_chars,
+                ),
+            )
+        )
+        if len(self.events) > self._max_events:
+            del self.events[: len(self.events) - self._max_events]
+
+
+def should_record_security_audit(security: Any) -> bool:
+    recorder = getattr(security, "audit_recorder", None)
+    if not callable(getattr(recorder, "record", None)):
+        return False
+    if not getattr(security, "is_compat", False):
+        return True
+    return not bool(getattr(recorder, "_lark_channel_default_recorder", False))
+
+
+def build_error_response_content(error: BaseException, *, security: Any) -> bytes:
+    if getattr(security, "enforce_strict_error_response", False):
+        body = {"code": 500, "msg": "internal error"}
+        return JSON.marshal(body).encode(UTF_8)
+    return ('{"msg":"%s"}' % str(error)).encode(UTF_8)
+
+
+def _validate_positive_int(name: str, value: int) -> int:
+    if not isinstance(value, int) or isinstance(value, bool):
+        raise TypeError(f"{name} must be a positive integer")
+    if value <= 0:
+        raise ValueError(f"{name} must be a positive integer")
+    return value
+
+
+def _redacted_details(
+    details: Optional[Mapping[str, Any]],
+    *,
+    max_string_chars: int,
+    max_items: int,
+    max_total_chars: int,
+) -> Dict[str, Any]:
+    budget = _DetailBudget(max_total_chars)
+    safe_details = _scrub_audit_text(
+        {} if details is None else details,
+        max_string_chars=max_string_chars,
+        max_items=max_items,
+        budget=budget,
+    )
+    if isinstance(safe_details, dict):
+        return safe_details
+    return {"details": safe_details}
+
+
+def _redacted_label(value: str, *, max_string_chars: int) -> str:
+    safe_value = _scrub_audit_text(
+        str(value),
+        max_string_chars=max_string_chars,
+        max_items=1,
+        budget=_DetailBudget(max_string_chars),
+    )
+    if isinstance(safe_value, str):
+        return safe_value
+    return str(safe_value)
+
+
+_PRIVATE_KEY_LABEL_RE = r"PRIVATE " + r"KEY"
+_PRIVATE_KEY_BLOCK_RE = re.compile(
+    r"(?is)-----BEGIN [A-Z0-9 ]*"
+    + _PRIVATE_KEY_LABEL_RE
+    + r"-----.*?-----END [A-Z0-9 ]*"
+    + _PRIVATE_KEY_LABEL_RE
+    + r"-----"
+)
+_PRIVATE_KEY_OPEN_RE = re.compile(
+    r"(?is)-----BEGIN [A-Z0-9 ]*" + _PRIVATE_KEY_LABEL_RE + r"-----.*"
+)
+_AUTHORIZATION_HEADER_RE = re.compile(
+    r"(?i)\b(Authorization\s*:\s*)([^\n\r]*)(?:\r?\n[ \t]+[^\n\r]*)*"
+)
+_BEARER_RE = re.compile(r"(?i)\bBearer\s+[^\n\r]+")
+_API_KEY_RE = re.compile(r"(?i)\b(X-Api-Key\s*:\s*)[^\n\r]+(?:\r?\n[ \t]+[^\n\r]*)*")
+_COOKIE_RE = re.compile(r"(?i)\b((?:Set-)?Cookie\s*:\s*)[^\n\r]*(?:\r?\n[ \t]+[^\n\r]*)*")
+_SECRET_KEY_PATTERN = (
+    r"verification[_-]?token|verificationToken|"
+    r"access[_-]?token|accessToken|refresh[_-]?token|refreshToken|"
+    r"tenant[_-]?access[_-]?token|tenantAccessToken|"
+    r"app[_-]?access[_-]?token|appAccessToken|"
+    r"user[_-]?access[_-]?token|userAccessToken|"
+    r"encrypt[_-]?key|encryptKey|app[_-]?secret|appSecret|"
+    r"client[_-]?secret|clientSecret|api[-_]?key|apiKey|"
+    r"x[_-]?api[_-]?key|xApiKey|private[_-]?key|privateKey|"
+    r"set[_-]?cookie|setCookie|cookie|password|secret|token"
+)
+_QUOTED_AUTHORIZATION_ASSIGNMENT_RE = re.compile(
+    r"(?is)\b(authorization)([\"']?\s*[:=]\s*)([\"'])(.*?)\3"
+)
+_UNCLOSED_QUOTED_AUTHORIZATION_ASSIGNMENT_RE = re.compile(
+    r"(?is)\b(authorization)([\"']?\s*[:=]\s*)([\"']).*"
+)
+_AUTHORIZATION_ASSIGNMENT_RE = re.compile(
+    r"(?i)\b(authorization)([\"']?\s*[:=]\s*)([^,\n\r&;]+)"
+)
+_QUOTED_ASSIGNMENT_SECRET_RE = re.compile(
+    rf"(?is)\b({_SECRET_KEY_PATTERN})([\"']?\s*[:=]\s*)([\"']).*?\3"
+)
+_UNCLOSED_QUOTED_ASSIGNMENT_SECRET_RE = re.compile(
+    rf"(?is)\b({_SECRET_KEY_PATTERN})([\"']?\s*[:=]\s*)([\"']).*"
+)
+_ASSIGNMENT_SECRET_RE = re.compile(
+    rf"(?i)\b({_SECRET_KEY_PATTERN})([\"']?\s*[:=]\s*)[^,\n\r&;]+"
+)
+_AUTHORIZATION_SCHEMES_TO_KEEP = {
+    "basic",
+    "bearer",
+    "digest",
+    "oauth",
+    "token",
+}
+_CAMEL_BOUNDARY_RE = re.compile(r"(?<=[a-z0-9])(?=[A-Z])")
+_NON_KEY_SEPARATOR_RE = re.compile(r"[^0-9A-Za-z]+")
+_AUDIT_SENSITIVE_KEYS = {
+    "authorization",
+    "token",
+    "verification_token",
+    "access_token",
+    "refresh_token",
+    "tenant_access_token",
+    "app_access_token",
+    "user_access_token",
+    "app_secret",
+    "client_secret",
+    "api_key",
+    "x_api_key",
+    "encrypt_key",
+    "private_key",
+    "cookie",
+    "set_cookie",
+    "secret",
+    "password",
+}
+
+
+class _DetailBudget:
+    def __init__(self, remaining: int) -> None:
+        self.remaining = remaining
+        self.exhausted = False
+
+    def consume(self, size: int) -> bool:
+        if self.exhausted:
+            return False
+        if size > self.remaining:
+            self.exhausted = True
+            return False
+        self.remaining -= size
+        return True
+
+
+def _scrub_audit_text(
+    value: Any,
+    *,
+    max_string_chars: int,
+    max_items: int,
+    budget: _DetailBudget,
+    seen: Optional[Set[int]] = None,
+) -> Any:
+    if seen is None:
+        seen = set()
+    if budget.exhausted:
+        return "<truncated details>"
+    if isinstance(value, (bytes, bytearray, memoryview)):
+        summary = f"<{len(value)} bytes>"
+        if not budget.consume(len(summary)):
+            return "<truncated details>"
+        return summary
+    if isinstance(value, str):
+        original_length = len(value)
+        if original_length > max_string_chars:
+            value = (
+                f"{value[:max_string_chars]}"
+                f"<truncated {original_length - max_string_chars} chars>"
+            )
+        value = _PRIVATE_KEY_BLOCK_RE.sub("<redacted private key>", value)
+        value = _PRIVATE_KEY_OPEN_RE.sub("<redacted private key>", value)
+        parsed = _try_parse_json_audit_string(value)
+        if parsed is not _NOT_JSON:
+            return _scrub_audit_text(
+                parsed,
+                max_string_chars=max_string_chars,
+                max_items=max_items,
+                budget=budget,
+                seen=seen,
+            )
+        value = _AUTHORIZATION_HEADER_RE.sub(_redact_authorization_header, value)
+        value = _BEARER_RE.sub("Bearer ***", value)
+        value = _API_KEY_RE.sub(lambda m: f"{m.group(1)}***", value)
+        value = _COOKIE_RE.sub(lambda m: f"{m.group(1)}***", value)
+        value = _QUOTED_AUTHORIZATION_ASSIGNMENT_RE.sub(
+            lambda m: (
+                f"{m.group(1)}{m.group(2)}{m.group(3)}"
+                f"{_redact_authorization_value(m.group(4))}{m.group(3)}"
+            ),
+            value,
+        )
+        value = _UNCLOSED_QUOTED_AUTHORIZATION_ASSIGNMENT_RE.sub(
+            lambda m: f"{m.group(1)}{m.group(2)}{m.group(3)}***",
+            value,
+        )
+        value = _AUTHORIZATION_ASSIGNMENT_RE.sub(
+            lambda m: f"{m.group(1)}{m.group(2)}{_redact_authorization_value(m.group(3))}",
+            value,
+        )
+        value = _QUOTED_ASSIGNMENT_SECRET_RE.sub(
+            lambda m: f"{m.group(1)}{m.group(2)}{m.group(3)}***{m.group(3)}",
+            value,
+        )
+        value = _UNCLOSED_QUOTED_ASSIGNMENT_SECRET_RE.sub(
+            lambda m: f"{m.group(1)}{m.group(2)}{m.group(3)}***",
+            value,
+        )
+        value = _ASSIGNMENT_SECRET_RE.sub(
+            lambda m: f"{m.group(1)}{m.group(2)}***",
+            value,
+        )
+        if len(value) > max_string_chars:
+            value = f"{value[:max_string_chars]}<truncated {len(value) - max_string_chars} chars>"
+        if not budget.consume(len(value)):
+            return "<truncated details>"
+        return value
+    if _is_mapping_like(value):
+        value_id = id(value)
+        if value_id in seen:
+            return "<cycle>"
+        seen.add(value_id)
+        redacted = {}
+        count = 0
+        try:
+            try:
+                iterator = _iter_mapping_items(value)
+            except Exception:
+                redacted["_truncated"] = "<truncated details>"
+                return redacted
+            for _ in range(max_items):
+                try:
+                    key, item = next(iterator)
+                except StopIteration:
+                    break
+                except Exception:
+                    redacted["_truncated"] = "<truncated details>"
+                    break
+                if budget.exhausted:
+                    redacted["_truncated"] = "<truncated details>"
+                    break
+                safe_key_text = _safe_key_text(key)
+                normalized_key = _normalize_audit_key_text(safe_key_text)
+                key_is_sensitive = _is_audit_sensitive_key(normalized_key)
+                safe_key = _scrub_audit_key(
+                    safe_key_text,
+                    max_string_chars=max_string_chars,
+                    max_items=max_items,
+                    budget=budget,
+                    seen=seen,
+                )
+                if budget.exhausted:
+                    redacted["_truncated"] = "<truncated details>"
+                    break
+                if key_is_sensitive:
+                    item_value = _scrub_sensitive_value(
+                        normalized_key,
+                        item,
+                        max_string_chars=max_string_chars,
+                        max_items=max_items,
+                        budget=budget,
+                        seen=seen,
+                    )
+                else:
+                    item_value = _scrub_audit_text(
+                        item,
+                        max_string_chars=max_string_chars,
+                        max_items=max_items,
+                        budget=budget,
+                        seen=seen,
+                    )
+                if budget.exhausted:
+                    redacted["_truncated"] = "<truncated details>"
+                    break
+                redacted[safe_key] = item_value
+                count += 1
+            length = _safe_len(value)
+            if (
+                redacted.get("_truncated") != "<truncated details>"
+                and length is not None
+                and length > count
+            ):
+                redacted["_truncated"] = f"<truncated {length - count} items>"
+            return redacted
+        finally:
+            seen.discard(value_id)
+    if isinstance(value, list):
+        value_id = id(value)
+        if value_id in seen:
+            return "<cycle>"
+        seen.add(value_id)
+        redacted = []
+        try:
+            for item in value[:max_items]:
+                if budget.exhausted:
+                    redacted.append("<truncated details>")
+                    break
+                redacted.append(_scrub_audit_text(
+                    item,
+                    max_string_chars=max_string_chars,
+                    max_items=max_items,
+                    budget=budget,
+                    seen=seen,
+                ))
+            if len(value) > max_items:
+                redacted.append(f"<truncated {len(value) - max_items} items>")
+            return redacted
+        finally:
+            seen.discard(value_id)
+    if isinstance(value, tuple):
+        value_id = id(value)
+        if value_id in seen:
+            return "<cycle>"
+        seen.add(value_id)
+        redacted_items = []
+        try:
+            for item in value[:max_items]:
+                if budget.exhausted:
+                    redacted_items.append("<truncated details>")
+                    break
+                redacted_items.append(_scrub_audit_text(
+                    item,
+                    max_string_chars=max_string_chars,
+                    max_items=max_items,
+                    budget=budget,
+                    seen=seen,
+                ))
+            redacted = tuple(redacted_items)
+            if len(value) > max_items:
+                return redacted + (f"<truncated {len(value) - max_items} items>",)
+            return redacted
+        finally:
+            seen.discard(value_id)
+    if not isinstance(value, (int, float, bool, type(None))):
+        summary = f"<{type(value).__name__}>"
+        if not budget.consume(len(summary)):
+            return "<truncated details>"
+        return summary
+    if not budget.consume(len(_audit_scalar_size_text(value))):
+        return "<truncated details>"
+    return value
+
+
+_NOT_JSON = object()
+
+
+def _try_parse_json_audit_string(value: str) -> Any:
+    stripped = value.strip()
+    if not stripped.startswith(("{", "[")):
+        return _NOT_JSON
+    try:
+        return json.loads(stripped)
+    except (TypeError, ValueError, RecursionError):
+        return _NOT_JSON
+
+
+def _redact_authorization_header(match: re.Match) -> str:
+    value = match.group(2).strip()
+    scheme = value.split(None, 1)[0] if value else ""
+    if scheme.lower() in _AUTHORIZATION_SCHEMES_TO_KEEP:
+        return f"{match.group(1)}{scheme} ***"
+    return f"{match.group(1)}***"
+
+
+def _is_mapping_like(value: Any) -> bool:
+    if isinstance(value, dict):
+        return True
+    try:
+        items = getattr(value, "items", None)
+    except Exception:
+        return False
+    return callable(items)
+
+
+def _iter_mapping_items(value: Any):
+    return iter(value.items())
+
+
+def _safe_len(value: Any) -> Optional[int]:
+    if not isinstance(value, (dict, list, tuple)):
+        return None
+    try:
+        return len(value)
+    except Exception:
+        return None
+
+
+def _scrub_audit_key(
+    key_text: str,
+    *,
+    max_string_chars: int,
+    max_items: int,
+    budget: _DetailBudget,
+    seen: Set[int],
+) -> str:
+    scrubbed = _scrub_audit_text(
+        key_text,
+        max_string_chars=max_string_chars,
+        max_items=max_items,
+        budget=budget,
+        seen=seen,
+    )
+    if isinstance(scrubbed, str):
+        return scrubbed
+    try:
+        marshaled = JSON.marshal(scrubbed)
+    except (TypeError, ValueError):
+        marshaled = None
+    if marshaled:
+        return marshaled
+    return f"<{type(scrubbed).__name__}>"
+
+
+def _normalize_audit_key(value: Any) -> str:
+    return _normalize_audit_key_text(_safe_key_text(value))
+
+
+def _normalize_audit_key_text(value: str) -> str:
+    text = _CAMEL_BOUNDARY_RE.sub("_", value)
+    return _NON_KEY_SEPARATOR_RE.sub("_", text).strip("_").lower()
+
+
+def _safe_key_text(value: Any) -> str:
+    try:
+        return str(value)
+    except Exception:
+        return f"<{type(value).__name__}>"
+
+
+def _is_audit_sensitive_key(normalized_key: str) -> bool:
+    if _is_authorization_key(normalized_key):
+        return True
+    return any(
+        normalized_key == key or normalized_key.endswith(f"_{key}")
+        for key in _AUDIT_SENSITIVE_KEYS
+    )
+
+
+def _is_authorization_key(normalized_key: str) -> bool:
+    return "authorization" in normalized_key.split("_")
+
+
+def _scrub_sensitive_value(
+    normalized_key: str,
+    value: Any,
+    *,
+    max_string_chars: int,
+    max_items: int,
+    budget: _DetailBudget,
+    seen: Optional[Set[int]] = None,
+) -> Any:
+    if _is_authorization_key(normalized_key) and isinstance(value, str):
+        safe_value = _redact_authorization_value(value)
+        return _scrub_audit_text(
+            safe_value,
+            max_string_chars=max_string_chars,
+            max_items=max_items,
+            budget=budget,
+            seen=seen,
+        )
+    return _scrub_audit_text(
+        "***",
+        max_string_chars=max_string_chars,
+        max_items=max_items,
+        budget=budget,
+        seen=seen,
+    )
+
+
+def _redact_authorization_value(value: str) -> str:
+    stripped = value.strip()
+    scheme = stripped.split(None, 1)[0] if stripped else ""
+    if scheme.lower() in _AUTHORIZATION_SCHEMES_TO_KEEP and len(stripped) > len(scheme):
+        return f"{scheme} ***"
+    return "***"
+
+
+def _audit_scalar_size_text(value: Any) -> str:
+    try:
+        marshaled = JSON.marshal(value)
+    except (TypeError, ValueError):
+        return str(value)
+    if marshaled is None:
+        return "null"
+    return marshaled
diff --git a/lark_channel/event/tests/__init__.py b/lark_channel/event/tests/__init__.py
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/lark_channel/event/tests/__init__.py
@@ -0,0 +1 @@
+
diff --git a/lark_channel/event/tests/test_security.py b/lark_channel/event/tests/test_security.py
new file mode 100644
index 0000000..716168b
--- /dev/null
+++ b/lark_channel/event/tests/test_security.py
@@ -0,0 +1,1106 @@
+import logging
+
+import pytest
+
+from lark_channel.channel.config import SecurityConfig
+from lark_channel.event.security import (
+    REASON_CARD_DECRYPT_FAILED,
+    REASON_CARD_SIGNATURE_INVALID,
+    REASON_CARD_SIGNATURE_MISSING,
+    REASON_CARD_TOKEN_INVALID,
+    REASON_CARD_TOKEN_MISSING,
+    REASON_CONTENT_TEXT_UNSAFE_LEGACY,
+    REASON_MENTIONS_TEXT_ONLY,
+    REASON_RESOURCE_LIMIT_WOULD_BLOCK,
+    REASON_TOKEN_CACHE_LEGACY_FALLBACK,
+    REASON_WEBHOOK_DECRYPT_FAILED,
+    REASON_WEBHOOK_DECRYPT_WITHOUT_VERIFIED_SIGNATURE,
+    REASON_WEBHOOK_SIGNATURE_INVALID,
+    REASON_WEBHOOK_SIGNATURE_MISSING,
+    REASON_WEBHOOK_TOKEN_INVALID,
+    REASON_WEBHOOK_TOKEN_MISSING,
+    REASON_WS_FRAGMENT_LIMIT,
+    REASON_WS_INSECURE_SCHEME,
+    REASON_WS_INVALID_TIMING,
+    InMemorySecurityAuditRecorder,
+    SecurityAuditEvent,
+    SecurityAuditRecorder,
+    should_record_security_audit,
+)
+
+
+def _fake_private_key_block() -> str:
+    begin = "-----BEGIN " + "PRIVATE " + "KEY-----"
+    end = "-----END " + "PRIVATE " + "KEY-----"
+    return "\n".join(
+        [
+            begin,
+            "private-key-line-one",
+            "private-key-line-two",
+            end,
+        ]
+    )
+
+
+def test_security_audit_recorder_emits_stable_reason_code(caplog):
+    recorder = SecurityAuditRecorder()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={"path": "/callback"},
+        )
+
+    assert REASON_WEBHOOK_SIGNATURE_MISSING in caplog.text
+    assert "mode=audit" in caplog.text
+    assert "action=would_block" in caplog.text
+
+
+def test_default_compat_security_does_not_record_audit_by_default():
+    assert should_record_security_audit(SecurityConfig()) is False
+
+
+def test_audit_and_strict_security_record_audit_by_default():
+    assert should_record_security_audit(SecurityConfig(mode="audit")) is True
+    assert should_record_security_audit(SecurityConfig(mode="strict")) is True
+
+
+def test_compat_security_records_when_recorder_is_explicit():
+    recorder = InMemorySecurityAuditRecorder()
+
+    assert (
+        should_record_security_audit(
+            SecurityConfig(mode="compat", audit_recorder=recorder)
+        )
+        is True
+    )
+
+
+def test_compat_security_records_when_base_recorder_is_explicit():
+    recorder = SecurityAuditRecorder()
+
+    assert (
+        should_record_security_audit(
+            SecurityConfig(mode="compat", audit_recorder=recorder)
+        )
+        is True
+    )
+
+
+def test_security_reason_codes_cover_webhook_and_card_auth_failures():
+    assert REASON_WEBHOOK_TOKEN_MISSING == "webhook.token_missing"
+    assert REASON_WEBHOOK_TOKEN_INVALID == "webhook.token_invalid"
+    assert REASON_WEBHOOK_SIGNATURE_MISSING == "webhook.signature_missing"
+    assert REASON_WEBHOOK_SIGNATURE_INVALID == "webhook.signature_invalid"
+    assert (
+        REASON_WEBHOOK_DECRYPT_WITHOUT_VERIFIED_SIGNATURE
+        == "webhook.decrypt_without_verified_signature"
+    )
+    assert REASON_WEBHOOK_DECRYPT_FAILED == "webhook.decrypt_failed"
+    assert REASON_CARD_TOKEN_MISSING == "card.token_missing"
+    assert REASON_CARD_TOKEN_INVALID == "card.token_invalid"
+    assert REASON_CARD_SIGNATURE_MISSING == "card.signature_missing"
+    assert REASON_CARD_SIGNATURE_INVALID == "card.signature_invalid"
+    assert REASON_CARD_DECRYPT_FAILED == "card.decrypt_failed"
+
+
+def test_security_reason_codes_cover_transport_and_normalization_contracts():
+    assert REASON_WS_INSECURE_SCHEME == "ws.insecure_scheme"
+    assert REASON_WS_INVALID_TIMING == "ws.invalid_timing"
+    assert REASON_WS_FRAGMENT_LIMIT == "ws.fragment_limit"
+    assert REASON_RESOURCE_LIMIT_WOULD_BLOCK == "resource.limit_would_block"
+    assert REASON_MENTIONS_TEXT_ONLY == "mentions.text_only"
+    assert REASON_CONTENT_TEXT_UNSAFE_LEGACY == "content_text.unsafe_legacy"
+    assert REASON_TOKEN_CACHE_LEGACY_FALLBACK == "token_cache.legacy_fallback"
+
+
+def test_security_audit_recorder_redacts_sensitive_details(caplog):
+    recorder = SecurityAuditRecorder()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={
+                "authorization": "Bearer tenant-token-value",
+                "verification_token": "verification-token-value",
+                "body": {"app_secret": "secret-value", "safe": "visible"},
+            },
+        )
+
+    assert "tenant-token-value" not in caplog.text
+    assert "verification-token-value" not in caplog.text
+    assert "secret-value" not in caplog.text
+    assert "Bearer ***" in caplog.text
+    assert "visible" in caplog.text
+
+
+def test_security_audit_recorder_redacts_sensitive_free_text(caplog):
+    recorder = SecurityAuditRecorder()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={
+                "message": "Authorization: Bearer tenant-token-value",
+                "error": "verification_token=verification-token-value",
+                "raw": '{"app_secret":"secret-value","safe":"visible"}',
+            },
+        )
+
+    assert "tenant-token-value" not in caplog.text
+    assert "verification-token-value" not in caplog.text
+    assert "secret-value" not in caplog.text
+    assert "Bearer ***" in caplog.text
+    assert "visible" in caplog.text
+
+
+def test_security_audit_recorder_redacts_quoted_sensitive_free_text(caplog):
+    recorder = SecurityAuditRecorder()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={
+                "message": '"verification_token": "verification-token-value"',
+                "error": "'app_secret': 'secret-value'",
+                "note": 'client_secret = "client-secret-value"',
+            },
+        )
+
+    assert "verification-token-value" not in caplog.text
+    assert "secret-value" not in caplog.text
+    assert "client-secret-value" not in caplog.text
+    assert "verification_token" in caplog.text
+    assert "app_secret" in caplog.text
+    assert "client_secret" in caplog.text
+
+
+def test_security_audit_recorder_redacts_quoted_sensitive_free_text_with_spaces(caplog):
+    recorder = SecurityAuditRecorder()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={
+                "message": '"app_secret": "secret value with spaces"',
+                "error": "'client_secret': 'client secret value'",
+            },
+    )
+
+    assert "secret value with spaces" not in caplog.text
+    assert "value with spaces" not in caplog.text
+    assert "client secret value" not in caplog.text
+    assert "secret value" not in caplog.text
+    assert "app_secret" in caplog.text
+    assert "client_secret" in caplog.text
+
+
+def test_security_audit_recorder_redacts_common_auth_free_text(caplog):
+    recorder = SecurityAuditRecorder()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={
+                "basic": "Authorization: Basic basic-token-value",
+                "auth_text": "Authorization: Token token-auth-value",
+                "api_key_text": "X-Api-Key: api-key-value",
+                "secret": "client_secret = client secret value",
+            },
+        )
+
+    assert "basic-token-value" not in caplog.text
+    assert "token-auth-value" not in caplog.text
+    assert "api-key-value" not in caplog.text
+    assert "client secret value" not in caplog.text
+    assert "Authorization: Basic ***" in caplog.text
+    assert "Authorization: Token ***" in caplog.text
+    assert "X-Api-Key: ***" in caplog.text
+
+
+def test_security_audit_recorder_redacts_api_key_fields_and_free_text(caplog):
+    recorder = SecurityAuditRecorder()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={
+                "api_key": "api-key-value",
+                "x_api_key": "x-api-key-value",
+                "message": "api_key=free-text-api-key",
+            },
+        )
+
+    assert "api-key-value" not in caplog.text
+    assert "x-api-key-value" not in caplog.text
+    assert "free-text-api-key" not in caplog.text
+
+
+def test_security_audit_recorder_redacts_api_key_hyphen_variant(caplog):
+    recorder = SecurityAuditRecorder()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={"message": "api-key=hyphen-api-key-value"},
+        )
+
+    assert "hyphen-api-key-value" not in caplog.text
+
+
+def test_security_audit_recorder_redacts_cookie_and_private_key(caplog):
+    recorder = SecurityAuditRecorder()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={
+                "headers": {
+                    "Cookie": "sessionid=session-secret-value",
+                    "Set-Cookie": "sessionid=set-cookie-secret",
+                },
+                "private_key": "private-key-value",
+                "message": "Cookie: sessionid=free-text-cookie-secret",
+            },
+        )
+
+    assert "session-secret-value" not in caplog.text
+    assert "set-cookie-secret" not in caplog.text
+    assert "private-key-value" not in caplog.text
+    assert "free-text-cookie-secret" not in caplog.text
+
+
+def test_security_audit_recorder_redacts_encrypt_key_fields_and_free_text(caplog):
+    recorder = SecurityAuditRecorder()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={
+                "encrypt_key": "field-encrypt-key",
+                "nested": {"encrypt_key": "nested-encrypt-key"},
+                "message": "encrypt_key=free-text-encrypt-key",
+            },
+        )
+
+    assert "field-encrypt-key" not in caplog.text
+    assert "nested-encrypt-key" not in caplog.text
+    assert "free-text-encrypt-key" not in caplog.text
+
+
+def test_security_audit_recorder_redacts_sensitive_detail_keys(caplog):
+    recorder = SecurityAuditRecorder()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={
+                "Authorization: Bearer key-token-value": "visible",
+                "access_token=key-access-token": "visible",
+            },
+    )
+
+    assert "key-token-value" not in caplog.text
+    assert "key-access-token" not in caplog.text
+
+
+def test_security_audit_recorder_truncates_long_detail_keys(caplog):
+    recorder = SecurityAuditRecorder(max_detail_chars=8)
+    long_key = "k" * 64
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={long_key: "visible"},
+        )
+
+    assert long_key not in caplog.text
+    assert "<truncated" in caplog.text
+
+
+def test_security_audit_recorder_redacts_auth_free_text_with_spaces(caplog):
+    recorder = SecurityAuditRecorder()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={
+                "basic": "Authorization: Basic basic token with spaces",
+                "token_text": "Authorization: Token token value with spaces",
+                "api_key_text": "X-Api-Key: api key value with spaces",
+            },
+        )
+
+    assert "basic token with spaces" not in caplog.text
+    assert "token value with spaces" not in caplog.text
+    assert "api key value with spaces" not in caplog.text
+
+
+def test_security_audit_recorder_redacts_auth_header_with_delimited_values(caplog):
+    recorder = SecurityAuditRecorder()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={
+                "cookie_text": "Cookie: sessionid=secret-one; csrf=secret-two",
+                "token_text": "Authorization: Token token-value;next=leak-value",
+                "basic": "Authorization: Basic basic-value,second-value",
+            },
+        )
+
+    assert "secret-one" not in caplog.text
+    assert "secret-two" not in caplog.text
+    assert "token-value" not in caplog.text
+    assert "leak-value" not in caplog.text
+    assert "basic-value" not in caplog.text
+    assert "second-value" not in caplog.text
+
+
+def test_security_audit_recorder_redacts_extended_auth_and_secret_forms(caplog):
+    recorder = SecurityAuditRecorder()
+
+    private_key = _fake_private_key_block()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={
+                "query": "accessToken=query-token-value&clientSecret=client-secret-value",
+                "oauth": "Authorization: OAuth oauth-token-value",
+                "header_block": "Authorization: Bearer first-line-token\n second-line-token",
+                "privateKey": private_key,
+                "message": private_key,
+            },
+        )
+
+    assert "query-token-value" not in caplog.text
+    assert "client-secret-value" not in caplog.text
+    assert "oauth-token-value" not in caplog.text
+    assert "first-line-token" not in caplog.text
+    assert "second-line-token" not in caplog.text
+    assert "private-key-line-one" not in caplog.text
+    assert "private-key-line-two" not in caplog.text
+
+
+def test_security_audit_recorder_redacts_nonstandard_authorization_headers(caplog):
+    recorder = SecurityAuditRecorder()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={
+                "oauth_equals": "Authorization: OAuth=oauth-token-value",
+                "basic_colon": "Authorization: Basic: basic-token-value",
+                "custom": "Authorization: CustomScheme custom-token-value",
+            },
+        )
+
+    assert "oauth-token-value" not in caplog.text
+    assert "basic-token-value" not in caplog.text
+    assert "custom-token-value" not in caplog.text
+
+
+def test_security_audit_recorder_redacts_authorization_field_values(caplog):
+    recorder = SecurityAuditRecorder()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={
+                "Authorization": "Basic basic-token-value",
+                "nested": {"authorization": "Token token-value"},
+                "json": '{"Authorization": "OAuth oauth-token-value"}',
+                "custom": {"authorization": "CustomScheme custom-token-value"},
+            },
+        )
+
+    assert "basic-token-value" not in caplog.text
+    assert "token-value" not in caplog.text
+    assert "oauth-token-value" not in caplog.text
+    assert "custom-token-value" not in caplog.text
+    assert '"Authorization": "Basic ***"' in caplog.text
+    assert '"authorization": "Token ***"' in caplog.text
+
+
+def test_security_audit_recorder_redacts_authorization_path_keys(caplog):
+    recorder = SecurityAuditRecorder()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={
+                "headers.authorization": "Basic dotted-token-value",
+                "request.headers.Authorization": "Bearer nested-token-value",
+                "Authorization Header": "Token spaced-token-value",
+            },
+        )
+
+    assert "dotted-token-value" not in caplog.text
+    assert "nested-token-value" not in caplog.text
+    assert "spaced-token-value" not in caplog.text
+    assert "Basic ***" in caplog.text
+    assert "Bearer ***" in caplog.text
+    assert "Token ***" in caplog.text
+
+
+def test_security_audit_recorder_redacts_folded_x_api_key_header(caplog):
+    recorder = SecurityAuditRecorder()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={"message": "X-Api-Key: first-line-secret\n second-line-secret"},
+        )
+
+    assert "first-line-secret" not in caplog.text
+    assert "second-line-secret" not in caplog.text
+    assert "X-Api-Key: ***" in caplog.text
+
+
+def test_security_audit_recorder_truncates_large_detail_strings(caplog):
+    recorder = SecurityAuditRecorder(max_detail_chars=16)
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={"raw": "x" * 64},
+        )
+
+    assert "x" * 64 not in caplog.text
+    assert "<truncated" in caplog.text
+
+
+def test_security_audit_recorder_limits_detail_collection_width(caplog):
+    recorder = SecurityAuditRecorder(max_detail_items=2)
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={
+                "first": "visible-1",
+                "second": "visible-2",
+                "third": "hidden-3",
+            },
+        )
+
+    assert "visible-1" in caplog.text
+    assert "visible-2" in caplog.text
+    assert "hidden-3" not in caplog.text
+    assert "<truncated" in caplog.text
+
+
+def test_security_audit_recorder_redacts_escaped_quote_secret_suffix(caplog):
+    recorder = SecurityAuditRecorder()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={"message": r'app_secret="abc\"def"'},
+        )
+
+    assert "abc" not in caplog.text
+    assert "def" not in caplog.text
+    assert "app_secret" in caplog.text
+
+
+def test_security_audit_recorder_redacts_quoted_secret_with_delimiters(caplog):
+    recorder = SecurityAuditRecorder()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={
+                "comma": 'app_secret="abc,def"',
+                "semicolon": "client_secret='abc;def'",
+                "ampersand": 'encrypt_key="abc&def"',
+            },
+        )
+
+    assert "abc,def" not in caplog.text
+    assert "abc;def" not in caplog.text
+    assert "abc&def" not in caplog.text
+
+
+def test_security_audit_recorder_redacts_multiline_secret_assignment(caplog):
+    recorder = SecurityAuditRecorder()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={
+                "message": 'app_secret="line-one-secret\nline-two-secret"',
+                "camel": "clientSecret='camel-one-secret\ncamel-two-secret'",
+            },
+        )
+
+    assert "line-one-secret" not in caplog.text
+    assert "line-two-secret" not in caplog.text
+    assert "camel-one-secret" not in caplog.text
+    assert "camel-two-secret" not in caplog.text
+
+
+def test_security_audit_recorder_redacts_unclosed_multiline_secret_assignment(caplog):
+    recorder = SecurityAuditRecorder()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={
+                "message": 'app_secret="line-one-secret\nline-two-secret',
+                "camel": "clientSecret='camel-one-secret\ncamel-two-secret",
+            },
+        )
+
+    assert "line-one-secret" not in caplog.text
+    assert "line-two-secret" not in caplog.text
+    assert "camel-one-secret" not in caplog.text
+    assert "camel-two-secret" not in caplog.text
+
+
+def test_security_audit_recorder_redacts_unquoted_authorization_assignment(caplog):
+    recorder = SecurityAuditRecorder()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={
+                "basic": "authorization=Basic basic-token-value",
+                "token": "authorization = Token token-value",
+                "custom": "authorization=CustomScheme custom-token-value",
+            },
+        )
+
+    assert "basic-token-value" not in caplog.text
+    assert "token-value" not in caplog.text
+    assert "custom-token-value" not in caplog.text
+
+
+def test_security_audit_recorder_redacts_pem_before_truncating(caplog):
+    recorder = SecurityAuditRecorder(max_detail_chars=64)
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={
+                "message": _fake_private_key_block()
+            },
+        )
+
+    assert "private-key-line-one" not in caplog.text
+    assert "private-key-line-two" not in caplog.text
+    assert "<redacted private key>" in caplog.text
+
+
+def test_security_audit_recorder_does_not_return_unknown_objects(caplog):
+    class SecretCarrier:
+        def __init__(self):
+            self.app_secret = "object-attr-secret-value"
+
+    recorder = SecurityAuditRecorder()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={"object": SecretCarrier()},
+        )
+
+    assert "object-attr-secret-value" not in caplog.text
+    assert "<SecretCarrier>" in caplog.text
+
+
+def test_security_audit_recorder_handles_unserializable_unknown_objects(caplog):
+    class ExplodingValue:
+        def __deepcopy__(self, memo):
+            raise RuntimeError("deepcopy should not be called")
+
+    class SecretCarrier:
+        def __init__(self):
+            self.app_secret = "object-attr-secret-value"
+            self.exploding = ExplodingValue()
+
+    recorder = SecurityAuditRecorder()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={"object": SecretCarrier()},
+        )
+
+    assert "object-attr-secret-value" not in caplog.text
+    assert "deepcopy should not be called" not in caplog.text
+    assert "<SecretCarrier>" in caplog.text
+
+
+def test_security_audit_recorder_truncates_before_processing_large_strings(caplog):
+    recorder = SecurityAuditRecorder(max_detail_chars=32)
+    raw = "prefix-" + ("x" * 10000) + "app_secret=tail-secret"
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={"raw": raw},
+        )
+
+    assert "tail-secret" not in caplog.text
+    assert "x" * 1000 not in caplog.text
+    assert "<truncated" in caplog.text
+
+
+def test_security_audit_recorder_applies_total_detail_budget(caplog):
+    recorder = SecurityAuditRecorder(max_detail_chars=64, max_detail_total_chars=96)
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={
+                "first": "a" * 64,
+                "second": "b" * 64,
+                "third": "c" * 64,
+            },
+        )
+
+    assert "c" * 64 not in caplog.text
+    assert "<truncated details>" in caplog.text
+
+
+def test_security_audit_recorder_counts_sensitive_values_in_total_budget(caplog):
+    recorder = SecurityAuditRecorder(max_detail_total_chars=10)
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={"api_key": "api-key-value", "x": "1"},
+        )
+
+    assert '"api_key": "***"' in caplog.text
+    assert '"x": "1"' not in caplog.text
+    assert "<truncated details>" in caplog.text
+
+
+def test_security_audit_recorder_counts_non_string_scalars_in_total_budget(caplog):
+    recorder = SecurityAuditRecorder(max_detail_total_chars=32)
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={
+                "first": 10**80,
+                "second": "hidden",
+            },
+        )
+
+    assert str(10**80) not in caplog.text
+    assert "hidden" not in caplog.text
+    assert "<truncated details>" in caplog.text
+
+
+def test_security_audit_recorder_does_not_materialize_items_beyond_limit(caplog):
+    class ExplodingMapping:
+        def __iter__(self):
+            yield "first"
+            yield "second"
+            raise AssertionError("iterated beyond max detail items")
+
+        def __getitem__(self, key):
+            if key == "first":
+                return "visible-1"
+            if key == "second":
+                return "visible-2"
+            raise KeyError(key)
+
+        def items(self):
+            for key in self:
+                yield key, self[key]
+
+    recorder = SecurityAuditRecorder(max_detail_items=2)
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details=ExplodingMapping(),
+        )
+
+    assert "visible-1" in caplog.text
+    assert "visible-2" in caplog.text
+
+
+def test_security_audit_recorder_does_not_call_custom_mapping_len(caplog):
+    class LenExplodingMapping:
+        def __bool__(self):
+            raise AssertionError("bool called")
+
+        def __len__(self):
+            raise AssertionError("len called")
+
+        def items(self):
+            yield "first", "visible-1"
+            yield "second", "visible-2"
+
+    recorder = SecurityAuditRecorder(max_detail_items=2)
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details=LenExplodingMapping(),
+        )
+
+    assert "visible-1" in caplog.text
+    assert "visible-2" in caplog.text
+
+
+def test_security_audit_recorder_handles_mapping_items_creation_error(caplog):
+    class ItemsExplodingMapping:
+        def items(self):
+            raise RuntimeError("items should not escape")
+
+    recorder = SecurityAuditRecorder()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details=ItemsExplodingMapping(),
+        )
+
+    assert "items should not escape" not in caplog.text
+    assert "<truncated details>" in caplog.text
+
+
+def test_security_audit_recorder_handles_mapping_items_property_error(caplog):
+    class ItemsPropertyExplodingMapping:
+        @property
+        def items(self):
+            raise RuntimeError("items property secret should not escape")
+
+    recorder = SecurityAuditRecorder()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details=ItemsPropertyExplodingMapping(),
+        )
+
+    assert "items property secret should not escape" not in caplog.text
+    assert "<ItemsPropertyExplodingMapping>" in caplog.text
+
+
+def test_security_audit_recorder_handles_mapping_iteration_error(caplog):
+    class IterationExplodingMapping:
+        def items(self):
+            yield "first", "visible-1"
+            raise RuntimeError("iteration should not escape")
+
+    recorder = SecurityAuditRecorder()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details=IterationExplodingMapping(),
+        )
+
+    assert "visible-1" in caplog.text
+    assert "iteration should not escape" not in caplog.text
+    assert "<truncated details>" in caplog.text
+
+
+def test_security_audit_recorder_handles_cyclic_list(caplog):
+    cyclic = []
+    cyclic.append(cyclic)
+    recorder = SecurityAuditRecorder()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={"cycle": cyclic},
+        )
+
+    assert "<cycle>" in caplog.text
+
+
+def test_security_audit_recorder_handles_cyclic_mapping(caplog):
+    cyclic = {}
+    cyclic["self"] = cyclic
+    recorder = SecurityAuditRecorder()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details=cyclic,
+        )
+
+    assert "<cycle>" in caplog.text
+
+
+def test_security_audit_recorder_keeps_scrubbed_json_like_keys_hashable(caplog):
+    recorder = SecurityAuditRecorder()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={'{"app_secret":"key-secret-value"}': "visible"},
+        )
+
+    assert "key-secret-value" not in caplog.text
+    assert "visible" in caplog.text
+
+
+def test_security_audit_recorder_handles_key_string_error(caplog):
+    class ExplodingKey:
+        def __str__(self):
+            raise RuntimeError("key string secret should not escape")
+
+    recorder = SecurityAuditRecorder()
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={ExplodingKey(): "visible"},
+        )
+
+    assert "key string secret should not escape" not in caplog.text
+    assert "<ExplodingKey>" in caplog.text
+    assert "visible" in caplog.text
+
+
+def test_security_audit_recorder_scrubs_reason_mode_and_action(caplog):
+    recorder = SecurityAuditRecorder(max_detail_chars=16)
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        recorder.record(
+            "reason app_secret=reason-secret-value",
+            mode="mode Authorization: Bearer mode-token-value",
+            action="action " + "x" * 64,
+            details={"safe": "visible"},
+        )
+
+    assert "reason-secret-value" not in caplog.text
+    assert "mode-token-value" not in caplog.text
+    assert "x" * 64 not in caplog.text
+    assert "<truncated" in caplog.text
+
+
+def test_in_memory_security_audit_recorder_is_injectable():
+    recorder = InMemorySecurityAuditRecorder()
+
+    recorder.record(
+        REASON_WEBHOOK_SIGNATURE_MISSING,
+        mode="strict",
+        action="block",
+        details={"request_id": "req_1"},
+    )
+
+    assert recorder.events == [
+        SecurityAuditEvent(
+            reason=REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="strict",
+            action="block",
+            details={"request_id": "req_1"},
+        )
+    ]
+
+
+def test_in_memory_security_audit_recorder_redacts_sensitive_details():
+    recorder = InMemorySecurityAuditRecorder()
+
+    recorder.record(
+        REASON_WEBHOOK_SIGNATURE_MISSING,
+        mode="audit",
+        action="would_block",
+        details={
+            "authorization": "Bearer tenant-token-value",
+            "verification_token": "verification-token-value",
+            "body": {"app_secret": "secret-value", "safe": "visible"},
+        },
+    )
+
+    event = recorder.events[0]
+    assert event.details["authorization"] == "Bearer ***"
+    assert event.details["verification_token"] == "***"
+    assert event.details["body"]["app_secret"] == "***"
+    assert event.details["body"]["safe"] == "visible"
+
+
+def test_in_memory_security_audit_recorder_keeps_bounded_event_history():
+    recorder = InMemorySecurityAuditRecorder(max_events=2)
+
+    for index in range(3):
+        recorder.record(
+            REASON_WEBHOOK_SIGNATURE_MISSING,
+            mode="audit",
+            action="would_block",
+            details={"request_id": f"req_{index}"},
+        )
+
+    assert [event.details["request_id"] for event in recorder.events] == [
+        "req_1",
+        "req_2",
+    ]
+
+
+def test_in_memory_security_audit_recorder_truncates_large_detail_strings():
+    recorder = InMemorySecurityAuditRecorder(max_detail_chars=8)
+
+    recorder.record(
+        REASON_WEBHOOK_SIGNATURE_MISSING,
+        mode="audit",
+        action="would_block",
+        details={"raw": "x" * 64},
+    )
+
+    assert recorder.events[0].details["raw"].startswith("xxxxxxxx")
+    assert "<truncated" in recorder.events[0].details["raw"]
+
+
+def test_in_memory_security_audit_recorder_limits_detail_collection_width():
+    recorder = InMemorySecurityAuditRecorder(max_detail_items=2)
+
+    recorder.record(
+        REASON_WEBHOOK_SIGNATURE_MISSING,
+        mode="audit",
+        action="would_block",
+        details={"first": "visible-1", "second": "visible-2", "third": "hidden-3"},
+    )
+
+    assert recorder.events[0].details["first"] == "visible-1"
+    assert recorder.events[0].details["second"] == "visible-2"
+    assert "third" not in recorder.events[0].details
+    assert recorder.events[0].details["_truncated"] == "<truncated 1 items>"
+
+
+def test_in_memory_security_audit_recorder_applies_total_detail_budget():
+    recorder = InMemorySecurityAuditRecorder(
+        max_detail_chars=64,
+        max_detail_total_chars=96,
+    )
+
+    recorder.record(
+        REASON_WEBHOOK_SIGNATURE_MISSING,
+        mode="audit",
+        action="would_block",
+        details={
+            "first": "a" * 64,
+            "second": "b" * 64,
+            "third": "c" * 64,
+        },
+    )
+
+    assert recorder.events[0].details["first"] == "a" * 64
+    assert "second" not in recorder.events[0].details
+    assert "third" not in recorder.events[0].details
+    assert recorder.events[0].details["_truncated"] == "<truncated details>"
+
+
+@pytest.mark.parametrize("value", [0, -1])
+def test_in_memory_security_audit_recorder_max_events_must_be_positive(value):
+    with pytest.raises(ValueError, match="max_events"):
+        InMemorySecurityAuditRecorder(max_events=value)
+
+
+@pytest.mark.parametrize("value", [True, 1.5, "2"])
+def test_in_memory_security_audit_recorder_max_events_must_be_integer(value):
+    with pytest.raises(TypeError, match="max_events"):
+        InMemorySecurityAuditRecorder(max_events=value)
+
+
+@pytest.mark.parametrize(
+    "field_name",
+    ["max_detail_chars", "max_detail_items", "max_detail_total_chars"],
+)
+@pytest.mark.parametrize("value", [0, -1])
+def test_security_audit_recorder_limits_must_be_positive(field_name, value):
+    with pytest.raises(ValueError, match=field_name):
+        SecurityAuditRecorder(**{field_name: value})
+
+
+@pytest.mark.parametrize(
+    "field_name",
+    ["max_detail_chars", "max_detail_items", "max_detail_total_chars"],
+)
+@pytest.mark.parametrize("value", [True, 1.5, "2"])
+def test_security_audit_recorder_limits_must_be_integer(field_name, value):
+    with pytest.raises(TypeError, match=field_name):
+        SecurityAuditRecorder(**{field_name: value})
diff --git a/lark_channel/ws/__init__.py b/lark_channel/ws/__init__.py
new file mode 100644
index 0000000..3ff722b
--- /dev/null
+++ b/lark_channel/ws/__init__.py
@@ -0,0 +1 @@
+from .client import Client
diff --git a/lark_channel/ws/client.py b/lark_channel/ws/client.py
new file mode 100644
index 0000000..c9148a4
--- /dev/null
+++ b/lark_channel/ws/client.py
@@ -0,0 +1,706 @@
+import asyncio
+import base64
+import http
+import inspect
+import ipaddress
+import random
+import time
+from typing import Any, Callable, Dict, Mapping, Optional, TYPE_CHECKING
+from urllib.parse import urlparse, parse_qs
+
+import requests
+import websockets
+from websockets.exceptions import InvalidHandshake
+
+from lark_channel.core.cache import ExpiringCache
+from lark_channel.core.const import UTF_8, FEISHU_DOMAIN, USER_AGENT
+from lark_channel.core.enum import LogLevel
+from lark_channel.core.json import JSON
+from lark_channel.core.log import logger
+from lark_channel.core.utils import Strings
+from lark_channel.core.utils.user_agent import build_user_agent
+from lark_channel.event.dispatcher_handler import EventDispatcherHandler
+from lark_channel.event.security import (
+    REASON_WS_FRAGMENT_LIMIT,
+    REASON_WS_INSECURE_SCHEME,
+    REASON_WS_INVALID_TIMING,
+    should_record_security_audit,
+)
+from lark_channel.ws.const import *
+from lark_channel.ws.enum import FrameType, MessageType
+from lark_channel.ws.exception import *
+from lark_channel.ws.model import *
+from lark_channel.ws.pb.google.protobuf.internal.containers import RepeatedCompositeFieldContainer
+from lark_channel.ws.pb.pbbp2_pb2 import Frame
+
+if TYPE_CHECKING:
+    from lark_channel.channel.config import SecurityConfig
+
+
+try:
+    loop = asyncio.get_event_loop()
+except RuntimeError:
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+
+
+def _get_by_key(headers: RepeatedCompositeFieldContainer, key: str) -> str:
+    for header in headers:
+        if header.key == key:
+            return header.value
+
+    raise HeaderNotFoundException(key)
+
+
+def _new_ping_frame(service_id: int) -> Frame:
+    frame = Frame()
+    header = frame.headers.add()
+    header.key = HEADER_TYPE
+    header.value = MessageType.PING.value
+    frame.service = service_id
+    frame.method = FrameType.CONTROL.value
+    frame.SeqID = 0
+    frame.LogID = 0
+
+    return frame
+
+
+def _ordinal(n: int):
+    suffixes = {1: 'st', 2: 'nd', 3: 'rd'}
+    if 10 <= n <= 20:
+        suffix = 'th'
+    else:
+        suffix = suffixes.get(n % 10, 'th')
+    return str(n) + suffix
+
+
+async def _select():
+    while True:
+        await asyncio.sleep(3600)
+
+
+def _ws_connect_kwargs(proxy_url: Optional[str] = None, trust_env_proxy: Optional[bool] = None):
+    params = inspect.signature(websockets.connect).parameters
+    if "proxy" not in params:
+        if proxy_url:
+            raise RuntimeError("installed websockets does not support explicit proxy configuration")
+        return {}
+    if proxy_url:
+        return {"proxy": proxy_url}
+    if trust_env_proxy is True:
+        return {}
+    # websockets 15 enables environment proxy discovery by default. The SDK
+    # historically connected directly, so preserve that behavior when the
+    # parameter exists.
+    return {"proxy": None}
+
+
+def _endpoint_proxy_kwargs(proxy_url: Optional[str]) -> Dict[str, object]:
+    if proxy_url:
+        return {"proxies": {"http": proxy_url, "https": proxy_url}}
+    return {}
+
+
+def _post_endpoint(
+    url: str,
+    *,
+    headers: Dict[str, str],
+    body: Dict[str, str],
+    timeout: Optional[float],
+    proxy_url: Optional[str],
+    trust_env_proxy: Optional[bool],
+):
+    kwargs = {}
+    if timeout is not None:
+        kwargs["timeout"] = timeout
+    proxy_kwargs = _endpoint_proxy_kwargs(proxy_url)
+    if trust_env_proxy is False:
+        session = requests.Session()
+        session.trust_env = False
+        return session.post(url, headers=headers, json=body, **proxy_kwargs, **kwargs)
+    return requests.post(
+        url,
+        headers=headers,
+        json=body,
+        **proxy_kwargs,
+        **kwargs,
+    )
+
+
+def _get_ws_conn_exception_headers(e):
+    headers = getattr(e, "headers", None)
+    if headers is not None:
+        return headers
+
+    response = getattr(e, "response", None)
+    if response is None:
+        return None
+    return getattr(response, "headers", None)
+
+
+def _parse_ws_conn_exception(e):
+    headers = _get_ws_conn_exception_headers(e)
+    if headers is None:
+        raise e
+
+    code = headers.get(HEADER_HANDSHAKE_STATUS)
+    msg = headers.get(HEADER_HANDSHAKE_MSG)
+    if code is None or msg is None:
+        raise e
+
+    code = int(code)
+    if code == AUTH_FAILED:
+        auth_code = headers.get(HEADER_HANDSHAKE_AUTH_ERRCODE)
+        if int(auth_code) == EXCEED_CONN_LIMIT:
+            raise ClientException(code, msg)
+        else:
+            raise ServerException(code, msg)
+    elif code == FORBIDDEN:
+        raise ClientException(code, msg)
+    else:
+        raise ServerException(code, msg)
+
+
+class Client(object):
+    def __init__(self,
+                 app_id: str,
+                 app_secret,
+                 log_level: LogLevel = LogLevel.INFO,
+                 event_handler: EventDispatcherHandler = None,
+                 domain: str = FEISHU_DOMAIN,
+                 auto_reconnect: bool = True,
+                 source: Optional[str] = None,
+                 extra_ua_tags: Optional[list] = None,
+                 headers: Optional[Mapping[str, str]] = None,
+                 proxy_url: Optional[str] = None,
+                 trust_env_proxy: Optional[bool] = None,
+                 handshake_timeout: Optional[float] = None,
+                 security: Optional["SecurityConfig"] = None) -> None:
+        self._app_id: str = app_id
+        self._app_secret: str = app_secret
+        self._log_level: LogLevel = log_level
+        self._event_handler: EventDispatcherHandler = event_handler
+        self._auto_reconnect: bool = auto_reconnect
+        self._domain: str = domain
+        self._headers: Dict[str, str] = dict(headers or {})
+        self._proxy_url = proxy_url
+        self._trust_env_proxy = trust_env_proxy
+        self._handshake_timeout = handshake_timeout
+        self._security = security or _default_security_config()
+        # UA used on the endpoint-discovery POST (and any future HTTP/WS
+        # handshakes from this client). ``extra_ua_tags`` is internal; higher
+        # level modules may pass a short product tag here.
+        self._user_agent: str = build_user_agent(source=source, extra_tags=extra_ua_tags)
+        self._conn: Optional[websockets.WebSocketClientProtocol] = None
+        self._conn_url: str = ""
+        self._service_id: str = ""
+        self._conn_id: str = ""
+        self._loop = loop
+        self._reconnect_task = None
+        # Local defaults; the Feishu WS endpoint authoritatively replaces these
+        # via _configure() on every handshake (and may push updates mid-session
+        # via CONTROL frames). User-facing overrides are intentionally not
+        # exposed because the server replaces them.
+        self._reconnect_nonce: int = 30
+        self._reconnect_count: int = -1
+        self._reconnect_interval: int = 120
+        self._ping_interval: int = 120
+        self._cache: ExpiringCache = ExpiringCache(clear_interval=30)
+        self._lock = asyncio.Lock()
+        self._reconnect_lock = asyncio.Lock()
+        self._handler_semaphore = (
+            asyncio.Semaphore(self._security.max_concurrent_ws_handlers)
+            if self._security.max_concurrent_ws_handlers is not None
+            else None
+        )
+        # Observer hooks for higher-level wrappers (e.g. FeishuChannel) to
+        # react to reconnect lifecycle. ``on_reconnecting`` fires when the
+        # client decides a connection was lost and starts retrying;
+        # ``on_reconnected`` fires on the first successful re-establishment.
+        # Both default to no-op so existing callers see no behaviour change.
+        self.on_reconnecting: Callable[[], None] = lambda: None
+        self.on_reconnected: Callable[[], None] = lambda: None
+        logger.setLevel(log_level.value)
+
+    def start(self) -> None:
+        try:
+            loop.run_until_complete(self._connect())
+        except ClientException as e:
+            logger.error(self._fmt_log("connect failed, err: {}", e))
+            raise e
+        except Exception as e:
+            logger.error(self._fmt_log("connect failed, err: {}", e))
+            if self._auto_reconnect:
+                loop.run_until_complete(self._disconnect_and_reconnect())
+            else:
+                loop.run_until_complete(self._disconnect())
+                raise e
+
+        loop.create_task(self._ping_loop())
+        loop.run_until_complete(_select())
+
+    async def _ping_loop(self):
+        while True:
+            try:
+                if self._conn is not None:
+                    frame = _new_ping_frame(int(self._service_id))
+                    await self._write_message(frame.SerializeToString())
+                    logger.debug(self._fmt_log("ping success"))
+            except Exception as e:
+                logger.warn(self._fmt_log("ping failed, err: {}", e))
+            finally:
+                await asyncio.sleep(self._ping_interval)
+
+    async def _connect(self) -> None:
+        async with self._lock:
+            if self._conn is not None:
+                return
+            try:
+                if self._handshake_timeout is None:
+                    conn_url = self._get_conn_url()
+                else:
+                    conn_url = self._get_conn_url(timeout=self._handshake_timeout)
+                u = urlparse(conn_url)
+                self._validate_conn_url(u, conn_url)
+                q = parse_qs(u.query)
+                conn_id = q[DEVICE_ID][0]
+                service_id = q[SERVICE_ID][0]
+
+                connect_kwargs = _ws_connect_kwargs(self._proxy_url, self._trust_env_proxy)
+                if self._handshake_timeout is not None:
+                    connect_kwargs["open_timeout"] = self._handshake_timeout
+                conn = await websockets.connect(conn_url, **connect_kwargs)
+                self._conn = conn
+                self._conn_url = conn_url
+                self._conn_id = conn_id
+                self._service_id = service_id
+
+                logger.info(self._fmt_log("connected to {}", conn_url))
+                loop.create_task(self._receive_message_loop(conn))
+            except InvalidHandshake as e:
+                _parse_ws_conn_exception(e)
+
+    async def _receive_message_loop(self, conn):
+        try:
+            while True:
+                msg = await conn.recv()
+                await self._schedule_handle_message(msg)
+        except Exception as e:
+            logger.error(self._fmt_log("receive message loop exit, err: {}", e))
+            if self._auto_reconnect:
+                await self._disconnect_and_reconnect(expected_conn=conn)
+            else:
+                await self._disconnect(expected_conn=conn)
+                raise e
+
+    async def _schedule_handle_message(self, msg) -> None:
+        if self._handler_semaphore is None:
+            loop.create_task(self._handle_message(msg))
+            return
+        await self._handler_semaphore.acquire()
+        loop.create_task(self._handle_message_with_limit(msg))
+
+    async def _handle_message_with_limit(self, msg) -> None:
+        try:
+            await self._handle_message(msg)
+        finally:
+            self._handler_semaphore.release()
+
+    def _get_conn_url(self, *, timeout: Optional[float] = None) -> str:
+        if Strings.is_empty(self._app_id) or Strings.is_empty(self._app_secret):
+            raise ClientException(NO_CREDENTIAL, "app_id or app_secret is null")
+
+        headers = dict(self._headers)
+        headers.update({
+            "locale": "zh",
+            USER_AGENT: self._user_agent,
+        })
+        response = _post_endpoint(
+            self._domain + GEN_ENDPOINT_URI,
+            headers=headers,
+            body={
+                "AppID": self._app_id,
+                "AppSecret": self._app_secret,
+            },
+            timeout=timeout,
+            proxy_url=self._proxy_url,
+            trust_env_proxy=self._trust_env_proxy,
+        )
+        if response.status_code != http.HTTPStatus.OK:
+            raise ServerException(response.status_code, "system busy")
+
+        resp = JSON.unmarshal(str(response.content, UTF_8), EndpointResp)
+        if resp.code == OK:
+            pass
+        elif resp.code == SYSTEM_BUSY:
+            raise ServerException(resp.code, "system busy")
+        elif resp.code == INTERNAL_ERROR:
+            raise ServerException(resp.code, resp.msg)
+        else:
+            raise ClientException(resp.code, resp.msg)
+
+        data = resp.data
+        if data.ClientConfig is not None:
+            self._configure(data.ClientConfig)
+
+        return data.URL
+
+    def _validate_conn_url(self, parsed, conn_url: str) -> None:
+        scheme = (parsed.scheme or "").lower()
+        if scheme == "wss":
+            return
+        if scheme != "ws":
+            raise ClientException(FORBIDDEN, f"invalid websocket endpoint scheme: {scheme}")
+        if self._is_local_insecure_ws(parsed) and self._security.allow_local_insecure_ws:
+            return
+        self._record_security_audit(
+            REASON_WS_INSECURE_SCHEME,
+            action=(
+                "allow"
+                if self._security.is_strict and self._security.allow_insecure_ws
+                else "block"
+                if self._security.is_strict
+                else "legacy_flow"
+            ),
+            details={"url": conn_url},
+        )
+        if self._security.is_strict and not self._security.allow_insecure_ws:
+            raise ClientException(FORBIDDEN, "insecure websocket endpoint")
+
+    def _is_local_insecure_ws(self, parsed) -> bool:
+        hostname = parsed.hostname
+        if hostname is None:
+            return False
+        if hostname.lower() == "localhost":
+            return True
+        try:
+            return ipaddress.ip_address(hostname).is_loopback
+        except ValueError:
+            return False
+
+    def _set_loop(self, loop_) -> None:
+        self._loop = loop_
+        self._reconnect_task = None
+
+    def probe_endpoint(self, *, timeout: float) -> bool:
+        try:
+            self._get_conn_url(timeout=timeout)
+            return True
+        except Exception as e:
+            logger.warning(self._fmt_log("endpoint probe failed, err: {}", e))
+            return False
+
+    def request_reconnect(self) -> None:
+        active_loop = getattr(self, "_loop", None)
+        if active_loop is None or active_loop.is_closed() or not active_loop.is_running():
+            return
+        active_loop.call_soon_threadsafe(self._ensure_reconnect_task)
+
+    def _ensure_reconnect_task(self) -> None:
+        task = getattr(self, "_reconnect_task", None)
+        if task is not None and not task.done():
+            return
+        self._reconnect_task = asyncio.create_task(self._request_reconnect_once())
+        self._reconnect_task.add_done_callback(self._log_reconnect_task)
+
+    def _log_reconnect_task(self, task) -> None:
+        if task.cancelled():
+            return
+        exc = task.exception()
+        if exc is not None:
+            logger.warning(self._fmt_log("requested reconnect failed, err: {}", exc))
+
+    async def _request_reconnect_once(self) -> None:
+        await self._disconnect_and_reconnect()
+
+    async def _handle_message(self, msg: bytes) -> None:
+        try:
+            frame = Frame()
+            frame.ParseFromString(msg)
+            ft = FrameType(frame.method)
+
+            if ft == FrameType.CONTROL:
+                await self._handle_control_frame(frame)
+            elif ft == FrameType.DATA:
+                await self._handle_data_frame(frame)
+        except Exception as e:
+            logger.error(self._fmt_log("handle message failed, err: {}", e))
+
+    async def _handle_control_frame(self, frame: Frame):
+        hs = frame.headers
+        type_ = _get_by_key(hs, HEADER_TYPE)
+        message_type = MessageType(type_)
+
+        if message_type == MessageType.PING:
+            return
+        elif message_type == MessageType.PONG:
+            logger.debug(self._fmt_log("receive pong"))
+            if not frame.payload:
+                return
+            conf = JSON.unmarshal(str(frame.payload, UTF_8), ClientConfig)
+            self._configure(conf)
+
+    async def _handle_data_frame(self, frame: Frame):
+        hs = frame.headers
+        msg_id = _get_by_key(hs, HEADER_MESSAGE_ID)
+        trace_id = _get_by_key(hs, HEADER_TRACE_ID)
+        sum_ = _get_by_key(hs, HEADER_SUM)
+        seq = _get_by_key(hs, HEADER_SEQ)
+        type_ = _get_by_key(hs, HEADER_TYPE)
+
+        pl = frame.payload
+        if int(sum_) > 1:
+            # Reassemble the multi-part packet
+            pl = self._combine(msg_id, int(sum_), int(seq), pl)
+            if pl is None:
+                return
+
+        message_type = MessageType(type_)
+        logger.debug(self._fmt_log("receive message, message_type: {}, message_id: {}, trace_id: {}, payload_len: {}",
+                                   message_type.value, msg_id, trace_id, len(pl)))
+
+        resp = Response(code=http.HTTPStatus.OK)
+        try:
+            start = int(round(time.time() * 1000))
+            if message_type == MessageType.EVENT:
+                result = self._event_handler._do_without_validation(pl)
+            elif message_type == MessageType.CARD:
+                return
+            else:
+                return
+            end = int(round(time.time() * 1000))
+            header = hs.add()
+            header.key = HEADER_BIZ_RT
+            header.value = str(end - start)
+            if result is not None:
+                resp.data = base64.b64encode(JSON.marshal(result).encode(UTF_8))
+        except Exception as e:
+            logger.error(
+                self._fmt_log("handle message failed, message_type: {}, message_id: {}, trace_id: {}, err: {}",
+                              message_type.value, msg_id, trace_id, e))
+            resp = Response(code=http.HTTPStatus.INTERNAL_SERVER_ERROR)
+
+        frame.payload = JSON.marshal(resp).encode(UTF_8)
+        await self._write_message(frame.SerializeToString())
+
+    async def _reconnect(self):
+        async with self._reconnect_lock:
+            await self._reconnect_locked()
+
+    async def _disconnect_and_reconnect(self, *, expected_conn=None):
+        async with self._reconnect_lock:
+            disconnected = await self._disconnect(expected_conn=expected_conn)
+            if expected_conn is not None and not disconnected:
+                return False
+            await self._reconnect_locked()
+            return True
+
+    async def _reconnect_locked(self):
+        # Notify subscribers that we're about to try reconnecting. Wrapped in
+        # try/except so a misbehaving observer can never derail reconnect.
+        try:
+            self.on_reconnecting()
+        except Exception as e:  # pragma: no cover - defensive
+            logger.warning(self._fmt_log("on_reconnecting callback raised: {}", e))
+
+        # Random jitter before the first reconnect
+        if self._reconnect_nonce > 0:
+            nonce = random.random() * self._reconnect_nonce
+            await asyncio.sleep(nonce)
+
+        # Reconnect
+        if self._reconnect_count >= 0:
+            for i in range(self._reconnect_count):
+                if await self._try_connect(i):
+                    self._fire_on_reconnected()
+                    return
+                await asyncio.sleep(self._reconnect_interval)
+            raise ServerUnreachableException(
+                f"unable to connect to the server after trying {self._reconnect_count} times")
+        else:
+            i = 0
+            while True:
+                if await self._try_connect(i):
+                    self._fire_on_reconnected()
+                    return
+                await asyncio.sleep(self._reconnect_interval)
+                i += 1
+
+    def _fire_on_reconnected(self) -> None:
+        try:
+            self.on_reconnected()
+        except Exception as e:  # pragma: no cover - defensive
+            logger.warning(self._fmt_log("on_reconnected callback raised: {}", e))
+
+    async def _try_connect(self, cnt: int) -> bool:
+        logger.info(self._fmt_log("trying to reconnect for the {} time", _ordinal(cnt + 1)))
+        try:
+            await self._connect()
+            return True
+        except ClientException as e:
+            logger.error(self._fmt_log("connect failed, err: {}", e))
+            raise e
+        except Exception as e:
+            logger.error(self._fmt_log("connect failed, err: {}", e))
+            return False
+
+    async def _disconnect(self, *, expected_conn=None) -> bool:
+        async with self._lock:
+            if self._conn is None:
+                return False
+            if expected_conn is not None and self._conn is not expected_conn:
+                return False
+            try:
+                await self._conn.close()
+                logger.info(self._fmt_log("disconnected to {}", self._conn_url))
+            finally:
+                self._conn = None
+                self._conn_url = ""
+                self._conn_id = ""
+                self._service_id = ""
+            return True
+
+    async def _write_message(self, data: bytes):
+        async with self._lock:
+            if self._conn is None:
+                raise ConnectionClosedException("connection is closed, write message failed")
+            await self._conn.send(data)
+
+    def _combine(self, msg_id: str, sum_: int, seq: int, bs: bytes) -> Optional[bytes]:
+        if sum_ <= 1:
+            return bs
+        if seq < 0 or seq >= sum_:
+            self._record_security_audit(
+                REASON_WS_FRAGMENT_LIMIT,
+                action="drop",
+                details={"message_id": msg_id, "sum": sum_, "seq": seq},
+            )
+            return None
+        if self._fragment_parts_limit_exceeded(sum_):
+            self._record_security_audit(
+                REASON_WS_FRAGMENT_LIMIT,
+                action="drop" if self._should_drop_resource_overflow() else "would_block",
+                details={"message_id": msg_id, "sum": sum_, "seq": seq, "bytes": len(bs)},
+            )
+            if self._should_drop_resource_overflow():
+                return None
+
+        val = self._cache.get(msg_id)
+        if not isinstance(val, dict) or val.get("sum") != sum_:
+            val = {"sum": sum_, "parts": {}, "total_bytes": 0}
+
+        parts = val["parts"]
+        old = parts.get(seq)
+        if old is None:
+            val["total_bytes"] += len(bs)
+        else:
+            val["total_bytes"] += len(bs) - len(old)
+        if self._fragment_bytes_limit_exceeded(val["total_bytes"]):
+            self._record_security_audit(
+                REASON_WS_FRAGMENT_LIMIT,
+                action="drop" if self._should_drop_resource_overflow() else "would_block",
+                details={
+                    "message_id": msg_id,
+                    "sum": sum_,
+                    "seq": seq,
+                    "bytes": val["total_bytes"],
+                },
+            )
+            if self._should_drop_resource_overflow():
+                return None
+        parts[seq] = bs
+        if len(parts) < sum_:
+            self._cache.set(msg_id, val, 5)
+            return None
+
+        pl = b"".join(parts[i] for i in range(sum_))
+        return pl
+
+    def _configure(self, conf: ClientConfig) -> None:
+        self._reconnect_count = self._normalize_reconnect_count(conf.ReconnectCount)
+        self._reconnect_interval = self._normalize_interval(
+            conf.ReconnectInterval,
+            default=120,
+            field_name="ReconnectInterval",
+        )
+        self._reconnect_nonce = self._normalize_interval(
+            conf.ReconnectNonce,
+            default=30,
+            field_name="ReconnectNonce",
+        )
+        self._ping_interval = self._normalize_interval(
+            conf.PingInterval,
+            default=120,
+            field_name="PingInterval",
+        )
+
+    def _fragment_parts_limit_exceeded(self, parts: int) -> bool:
+        max_parts = self._security.max_ws_fragment_parts
+        return max_parts is not None and parts > max_parts
+
+    def _fragment_bytes_limit_exceeded(self, total_bytes: int) -> bool:
+        max_bytes = self._security.max_ws_fragment_bytes
+        return max_bytes is not None and total_bytes > max_bytes
+
+    def _should_drop_resource_overflow(self) -> bool:
+        return self._security.is_strict or self._security.resource_overflow_policy == "drop"
+
+    def _normalize_interval(
+        self,
+        value: Any,
+        *,
+        default: int,
+        field_name: str,
+    ) -> int:
+        if not isinstance(value, int) or isinstance(value, bool) or value <= 0 or value > 86400:
+            self._record_security_audit(
+                REASON_WS_INVALID_TIMING,
+                action="fallback",
+                details={"field": field_name, "value": value, "default": default},
+            )
+            return default
+        return value
+
+    def _normalize_reconnect_count(self, value: Any) -> int:
+        if (
+            not isinstance(value, int)
+            or isinstance(value, bool)
+            or value < -1
+            or value > 10000
+        ):
+            self._record_security_audit(
+                REASON_WS_INVALID_TIMING,
+                action="fallback",
+                details={"field": "ReconnectCount", "value": value, "default": -1},
+            )
+            return -1
+        return value
+
+    def _record_security_audit(
+        self,
+        reason: str,
+        *,
+        action: str,
+        details: Optional[Mapping[str, Any]] = None,
+    ) -> None:
+        if not should_record_security_audit(self._security):
+            return
+        self._security.audit_recorder.record(
+            reason,
+            mode=self._security.mode,
+            action=action,
+            details=details,
+        )
+
+    def _fmt_log(self, fmt: str, *args) -> str:
+        log = fmt.format(*args)
+        if self._conn_id != "":
+            log += f' [conn_id={self._conn_id}]'
+
+        return log
+
+
+def _default_security_config():
+    from lark_channel.channel.config import SecurityConfig
+
+    return SecurityConfig()
diff --git a/lark_channel/ws/const.py b/lark_channel/ws/const.py
new file mode 100644
index 0000000..8420738
--- /dev/null
+++ b/lark_channel/ws/const.py
@@ -0,0 +1,23 @@
+GEN_ENDPOINT_URI = "/callback/ws/endpoint"
+DEVICE_ID = "device_id"
+SERVICE_ID = "service_id"
+
+# ErrorCode
+OK = 0
+SYSTEM_BUSY = 1
+FORBIDDEN = 403
+AUTH_FAILED = 514
+INTERNAL_ERROR = 1000040343
+NO_CREDENTIAL = 1000040344
+EXCEED_CONN_LIMIT = 1000040350
+
+# Header
+HEADER_TYPE = "type"
+HEADER_MESSAGE_ID = "message_id"
+HEADER_SUM = "sum"
+HEADER_SEQ = "seq"
+HEADER_TRACE_ID = "trace_id"
+HEADER_BIZ_RT = "biz_rt"
+HEADER_HANDSHAKE_STATUS = "handshake-status"
+HEADER_HANDSHAKE_MSG = "handshake-msg"
+HEADER_HANDSHAKE_AUTH_ERRCODE = "handshake-autherrcode"
diff --git a/lark_channel/ws/enum.py b/lark_channel/ws/enum.py
new file mode 100644
index 0000000..37f8846
--- /dev/null
+++ b/lark_channel/ws/enum.py
@@ -0,0 +1,13 @@
+from enum import Enum
+
+
+class FrameType(Enum):
+    CONTROL = 0
+    DATA = 1
+
+
+class MessageType(Enum):
+    EVENT = "event"
+    CARD = "card"
+    PING = "ping"
+    PONG = "pong"
diff --git a/lark_channel/ws/exception.py b/lark_channel/ws/exception.py
new file mode 100644
index 0000000..88d89ac
--- /dev/null
+++ b/lark_channel/ws/exception.py
@@ -0,0 +1,34 @@
+class ClientException(Exception):
+    def __init__(self, code: int, msg: str):
+        super().__init__(msg)
+        self.code = code
+
+    def __str__(self):
+        return f"{self.code}: {super().__str__()}"
+
+
+class ServerException(Exception):
+    def __init__(self, code: int, msg: str):
+        super().__init__(msg)
+        self.code = code
+
+    def __str__(self):
+        return f"{self.code}: {super().__str__()}"
+
+
+class HeaderNotFoundException(Exception):
+    def __init__(self, key: str):
+        self.key = key
+
+    def __str__(self):
+        return f"{self.key} not found"
+
+
+class ConnectionClosedException(Exception):
+    def __init__(self, msg: str):
+        super().__init__(msg)
+
+
+class ServerUnreachableException(Exception):
+    def __init__(self, msg: str):
+        super().__init__(msg)
diff --git a/lark_channel/ws/model.py b/lark_channel/ws/model.py
new file mode 100644
index 0000000..f06ed3f
--- /dev/null
+++ b/lark_channel/ws/model.py
@@ -0,0 +1,44 @@
+from typing import Optional, Dict
+
+from lark_channel.core.construct import init
+
+
+class ClientConfig(object):
+    _types = {}
+
+    def __init__(self, d=None):
+        self.ReconnectCount: Optional[int] = None
+        self.ReconnectInterval: Optional[int] = None
+        self.ReconnectNonce: Optional[int] = None
+        self.PingInterval: Optional[int] = None
+        init(self, d, self._types)
+
+
+class Endpoint(object):
+    _types = {
+        "ClientConfig": ClientConfig
+    }
+
+    def __init__(self, d=None):
+        self.URL: Optional[str] = None
+        self.ClientConfig: Optional[ClientConfig] = None
+        init(self, d, self._types)
+
+
+class EndpointResp(object):
+    _types = {
+        "data": Endpoint
+    }
+
+    def __init__(self, d=None):
+        self.code: Optional[int] = None
+        self.msg: Optional[str] = None
+        self.data: Optional[Endpoint] = None
+        init(self, d, self._types)
+
+
+class Response(object):
+    def __init__(self, code: int = None, headers: Dict[str, str] = None, data: bytes = None):
+        self.code = code
+        self.headers = headers
+        self.data = data
diff --git a/lark_channel/ws/pb/__init__.py b/lark_channel/ws/pb/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/lark_channel/ws/pb/gogo_pb2.py b/lark_channel/ws/pb/gogo_pb2.py
new file mode 100644
index 0000000..c2f38c6
--- /dev/null
+++ b/lark_channel/ws/pb/gogo_pb2.py
@@ -0,0 +1,788 @@
+# -*- coding: utf-8 -*-
+# source: gogo.proto
+
+from lark_channel.ws.pb.google.protobuf import descriptor as _descriptor
+from lark_channel.ws.pb.google.protobuf import symbol_database as _symbol_database
+
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+from lark_channel.ws.pb.google.protobuf import descriptor_pb2 as google_dot_protobuf_dot_descriptor__pb2
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+    name='gogo.proto',
+    package='gogoproto',
+    syntax='proto2',
+    serialized_options=b'\n\023com.google.protobufB\nGoGoProtosZ\"github.com/gogo/protobuf/gogoproto',
+    create_key=_descriptor._internal_create_key,
+    serialized_pb=b'\n\ngogo.proto\x12\tgogoproto\x1a google/protobuf/descriptor.proto:;\n\x13goproto_enum_prefix\x12\x1c.google.protobuf.EnumOptions\x18\xb1\xe4\x03 \x01(\x08:=\n\x15goproto_enum_stringer\x12\x1c.google.protobuf.EnumOptions\x18\xc5\xe4\x03 \x01(\x08:5\n\renum_stringer\x12\x1c.google.protobuf.EnumOptions\x18\xc6\xe4\x03 \x01(\x08:7\n\x0f\x65num_customname\x12\x1c.google.protobuf.EnumOptions\x18\xc7\xe4\x03 \x01(\t:0\n\x08\x65numdecl\x12\x1c.google.protobuf.EnumOptions\x18\xc8\xe4\x03 \x01(\x08:A\n\x14\x65numvalue_customname\x12!.google.protobuf.EnumValueOptions\x18\xd1\x83\x04 \x01(\t:;\n\x13goproto_getters_all\x12\x1c.google.protobuf.FileOptions\x18\x99\xec\x03 \x01(\x08:?\n\x17goproto_enum_prefix_all\x12\x1c.google.protobuf.FileOptions\x18\x9a\xec\x03 \x01(\x08:<\n\x14goproto_stringer_all\x12\x1c.google.protobuf.FileOptions\x18\x9b\xec\x03 \x01(\x08:9\n\x11verbose_equal_all\x12\x1c.google.protobuf.FileOptions\x18\x9c\xec\x03 \x01(\x08:0\n\x08\x66\x61\x63\x65_all\x12\x1c.google.protobuf.FileOptions\x18\x9d\xec\x03 \x01(\x08:4\n\x0cgostring_all\x12\x1c.google.protobuf.FileOptions\x18\x9e\xec\x03 \x01(\x08:4\n\x0cpopulate_all\x12\x1c.google.protobuf.FileOptions\x18\x9f\xec\x03 \x01(\x08:4\n\x0cstringer_all\x12\x1c.google.protobuf.FileOptions\x18\xa0\xec\x03 \x01(\x08:3\n\x0bonlyone_all\x12\x1c.google.protobuf.FileOptions\x18\xa1\xec\x03 \x01(\x08:1\n\tequal_all\x12\x1c.google.protobuf.FileOptions\x18\xa5\xec\x03 \x01(\x08:7\n\x0f\x64\x65scription_all\x12\x1c.google.protobuf.FileOptions\x18\xa6\xec\x03 \x01(\x08:3\n\x0btestgen_all\x12\x1c.google.protobuf.FileOptions\x18\xa7\xec\x03 \x01(\x08:4\n\x0c\x62\x65nchgen_all\x12\x1c.google.protobuf.FileOptions\x18\xa8\xec\x03 \x01(\x08:5\n\rmarshaler_all\x12\x1c.google.protobuf.FileOptions\x18\xa9\xec\x03 \x01(\x08:7\n\x0funmarshaler_all\x12\x1c.google.protobuf.FileOptions\x18\xaa\xec\x03 \x01(\x08:<\n\x14stable_marshaler_all\x12\x1c.google.protobuf.FileOptions\x18\xab\xec\x03 \x01(\x08:1\n\tsizer_all\x12\x1c.google.protobuf.FileOptions\x18\xac\xec\x03 \x01(\x08:A\n\x19goproto_enum_stringer_all\x12\x1c.google.protobuf.FileOptions\x18\xad\xec\x03 \x01(\x08:9\n\x11\x65num_stringer_all\x12\x1c.google.protobuf.FileOptions\x18\xae\xec\x03 \x01(\x08:<\n\x14unsafe_marshaler_all\x12\x1c.google.protobuf.FileOptions\x18\xaf\xec\x03 \x01(\x08:>\n\x16unsafe_unmarshaler_all\x12\x1c.google.protobuf.FileOptions\x18\xb0\xec\x03 \x01(\x08:B\n\x1agoproto_extensions_map_all\x12\x1c.google.protobuf.FileOptions\x18\xb1\xec\x03 \x01(\x08:@\n\x18goproto_unrecognized_all\x12\x1c.google.protobuf.FileOptions\x18\xb2\xec\x03 \x01(\x08:8\n\x10gogoproto_import\x12\x1c.google.protobuf.FileOptions\x18\xb3\xec\x03 \x01(\x08:6\n\x0eprotosizer_all\x12\x1c.google.protobuf.FileOptions\x18\xb4\xec\x03 \x01(\x08:3\n\x0b\x63ompare_all\x12\x1c.google.protobuf.FileOptions\x18\xb5\xec\x03 \x01(\x08:4\n\x0ctypedecl_all\x12\x1c.google.protobuf.FileOptions\x18\xb6\xec\x03 \x01(\x08:4\n\x0c\x65numdecl_all\x12\x1c.google.protobuf.FileOptions\x18\xb7\xec\x03 \x01(\x08:<\n\x14goproto_registration\x12\x1c.google.protobuf.FileOptions\x18\xb8\xec\x03 \x01(\x08:7\n\x0fmessagename_all\x12\x1c.google.protobuf.FileOptions\x18\xb9\xec\x03 \x01(\x08:=\n\x15goproto_sizecache_all\x12\x1c.google.protobuf.FileOptions\x18\xba\xec\x03 \x01(\x08:;\n\x13goproto_unkeyed_all\x12\x1c.google.protobuf.FileOptions\x18\xbb\xec\x03 \x01(\x08::\n\x0fgoproto_getters\x12\x1f.google.protobuf.MessageOptions\x18\x81\xf4\x03 \x01(\x08:;\n\x10goproto_stringer\x12\x1f.google.protobuf.MessageOptions\x18\x83\xf4\x03 \x01(\x08:8\n\rverbose_equal\x12\x1f.google.protobuf.MessageOptions\x18\x84\xf4\x03 \x01(\x08:/\n\x04\x66\x61\x63\x65\x12\x1f.google.protobuf.MessageOptions\x18\x85\xf4\x03 \x01(\x08:3\n\x08gostring\x12\x1f.google.protobuf.MessageOptions\x18\x86\xf4\x03 \x01(\x08:3\n\x08populate\x12\x1f.google.protobuf.MessageOptions\x18\x87\xf4\x03 \x01(\x08:3\n\x08stringer\x12\x1f.google.protobuf.MessageOptions\x18\xc0\x8b\x04 \x01(\x08:2\n\x07onlyone\x12\x1f.google.protobuf.MessageOptions\x18\x89\xf4\x03 \x01(\x08:0\n\x05\x65qual\x12\x1f.google.protobuf.MessageOptions\x18\x8d\xf4\x03 \x01(\x08:6\n\x0b\x64\x65scription\x12\x1f.google.protobuf.MessageOptions\x18\x8e\xf4\x03 \x01(\x08:2\n\x07testgen\x12\x1f.google.protobuf.MessageOptions\x18\x8f\xf4\x03 \x01(\x08:3\n\x08\x62\x65nchgen\x12\x1f.google.protobuf.MessageOptions\x18\x90\xf4\x03 \x01(\x08:4\n\tmarshaler\x12\x1f.google.protobuf.MessageOptions\x18\x91\xf4\x03 \x01(\x08:6\n\x0bunmarshaler\x12\x1f.google.protobuf.MessageOptions\x18\x92\xf4\x03 \x01(\x08:;\n\x10stable_marshaler\x12\x1f.google.protobuf.MessageOptions\x18\x93\xf4\x03 \x01(\x08:0\n\x05sizer\x12\x1f.google.protobuf.MessageOptions\x18\x94\xf4\x03 \x01(\x08:;\n\x10unsafe_marshaler\x12\x1f.google.protobuf.MessageOptions\x18\x97\xf4\x03 \x01(\x08:=\n\x12unsafe_unmarshaler\x12\x1f.google.protobuf.MessageOptions\x18\x98\xf4\x03 \x01(\x08:A\n\x16goproto_extensions_map\x12\x1f.google.protobuf.MessageOptions\x18\x99\xf4\x03 \x01(\x08:?\n\x14goproto_unrecognized\x12\x1f.google.protobuf.MessageOptions\x18\x9a\xf4\x03 \x01(\x08:5\n\nprotosizer\x12\x1f.google.protobuf.MessageOptions\x18\x9c\xf4\x03 \x01(\x08:2\n\x07\x63ompare\x12\x1f.google.protobuf.MessageOptions\x18\x9d\xf4\x03 \x01(\x08:3\n\x08typedecl\x12\x1f.google.protobuf.MessageOptions\x18\x9e\xf4\x03 \x01(\x08:6\n\x0bmessagename\x12\x1f.google.protobuf.MessageOptions\x18\xa1\xf4\x03 \x01(\x08:<\n\x11goproto_sizecache\x12\x1f.google.protobuf.MessageOptions\x18\xa2\xf4\x03 \x01(\x08::\n\x0fgoproto_unkeyed\x12\x1f.google.protobuf.MessageOptions\x18\xa3\xf4\x03 \x01(\x08:1\n\x08nullable\x12\x1d.google.protobuf.FieldOptions\x18\xe9\xfb\x03 \x01(\x08:.\n\x05\x65mbed\x12\x1d.google.protobuf.FieldOptions\x18\xea\xfb\x03 \x01(\x08:3\n\ncustomtype\x12\x1d.google.protobuf.FieldOptions\x18\xeb\xfb\x03 \x01(\t:3\n\ncustomname\x12\x1d.google.protobuf.FieldOptions\x18\xec\xfb\x03 \x01(\t:0\n\x07jsontag\x12\x1d.google.protobuf.FieldOptions\x18\xed\xfb\x03 \x01(\t:1\n\x08moretags\x12\x1d.google.protobuf.FieldOptions\x18\xee\xfb\x03 \x01(\t:1\n\x08\x63\x61sttype\x12\x1d.google.protobuf.FieldOptions\x18\xef\xfb\x03 \x01(\t:0\n\x07\x63\x61stkey\x12\x1d.google.protobuf.FieldOptions\x18\xf0\xfb\x03 \x01(\t:2\n\tcastvalue\x12\x1d.google.protobuf.FieldOptions\x18\xf1\xfb\x03 \x01(\t:0\n\x07stdtime\x12\x1d.google.protobuf.FieldOptions\x18\xf2\xfb\x03 \x01(\x08:4\n\x0bstdduration\x12\x1d.google.protobuf.FieldOptions\x18\xf3\xfb\x03 \x01(\x08:3\n\nwktpointer\x12\x1d.google.protobuf.FieldOptions\x18\xf4\xfb\x03 \x01(\x08\x42\x45\n\x13\x63om.google.protobufB\nGoGoProtosZ\"github.com/gogo/protobuf/gogoproto'
+    ,
+    dependencies=[google_dot_protobuf_dot_descriptor__pb2.DESCRIPTOR, ])
+
+GOPROTO_ENUM_PREFIX_FIELD_NUMBER = 62001
+goproto_enum_prefix = _descriptor.FieldDescriptor(
+    name='goproto_enum_prefix', full_name='gogoproto.goproto_enum_prefix', index=0,
+    number=62001, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+GOPROTO_ENUM_STRINGER_FIELD_NUMBER = 62021
+goproto_enum_stringer = _descriptor.FieldDescriptor(
+    name='goproto_enum_stringer', full_name='gogoproto.goproto_enum_stringer', index=1,
+    number=62021, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+ENUM_STRINGER_FIELD_NUMBER = 62022
+enum_stringer = _descriptor.FieldDescriptor(
+    name='enum_stringer', full_name='gogoproto.enum_stringer', index=2,
+    number=62022, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+ENUM_CUSTOMNAME_FIELD_NUMBER = 62023
+enum_customname = _descriptor.FieldDescriptor(
+    name='enum_customname', full_name='gogoproto.enum_customname', index=3,
+    number=62023, type=9, cpp_type=9, label=1,
+    has_default_value=False, default_value=b"".decode('utf-8'),
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+ENUMDECL_FIELD_NUMBER = 62024
+enumdecl = _descriptor.FieldDescriptor(
+    name='enumdecl', full_name='gogoproto.enumdecl', index=4,
+    number=62024, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+ENUMVALUE_CUSTOMNAME_FIELD_NUMBER = 66001
+enumvalue_customname = _descriptor.FieldDescriptor(
+    name='enumvalue_customname', full_name='gogoproto.enumvalue_customname', index=5,
+    number=66001, type=9, cpp_type=9, label=1,
+    has_default_value=False, default_value=b"".decode('utf-8'),
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+GOPROTO_GETTERS_ALL_FIELD_NUMBER = 63001
+goproto_getters_all = _descriptor.FieldDescriptor(
+    name='goproto_getters_all', full_name='gogoproto.goproto_getters_all', index=6,
+    number=63001, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+GOPROTO_ENUM_PREFIX_ALL_FIELD_NUMBER = 63002
+goproto_enum_prefix_all = _descriptor.FieldDescriptor(
+    name='goproto_enum_prefix_all', full_name='gogoproto.goproto_enum_prefix_all', index=7,
+    number=63002, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+GOPROTO_STRINGER_ALL_FIELD_NUMBER = 63003
+goproto_stringer_all = _descriptor.FieldDescriptor(
+    name='goproto_stringer_all', full_name='gogoproto.goproto_stringer_all', index=8,
+    number=63003, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+VERBOSE_EQUAL_ALL_FIELD_NUMBER = 63004
+verbose_equal_all = _descriptor.FieldDescriptor(
+    name='verbose_equal_all', full_name='gogoproto.verbose_equal_all', index=9,
+    number=63004, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+FACE_ALL_FIELD_NUMBER = 63005
+face_all = _descriptor.FieldDescriptor(
+    name='face_all', full_name='gogoproto.face_all', index=10,
+    number=63005, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+GOSTRING_ALL_FIELD_NUMBER = 63006
+gostring_all = _descriptor.FieldDescriptor(
+    name='gostring_all', full_name='gogoproto.gostring_all', index=11,
+    number=63006, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+POPULATE_ALL_FIELD_NUMBER = 63007
+populate_all = _descriptor.FieldDescriptor(
+    name='populate_all', full_name='gogoproto.populate_all', index=12,
+    number=63007, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+STRINGER_ALL_FIELD_NUMBER = 63008
+stringer_all = _descriptor.FieldDescriptor(
+    name='stringer_all', full_name='gogoproto.stringer_all', index=13,
+    number=63008, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+ONLYONE_ALL_FIELD_NUMBER = 63009
+onlyone_all = _descriptor.FieldDescriptor(
+    name='onlyone_all', full_name='gogoproto.onlyone_all', index=14,
+    number=63009, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+EQUAL_ALL_FIELD_NUMBER = 63013
+equal_all = _descriptor.FieldDescriptor(
+    name='equal_all', full_name='gogoproto.equal_all', index=15,
+    number=63013, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+DESCRIPTION_ALL_FIELD_NUMBER = 63014
+description_all = _descriptor.FieldDescriptor(
+    name='description_all', full_name='gogoproto.description_all', index=16,
+    number=63014, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+TESTGEN_ALL_FIELD_NUMBER = 63015
+testgen_all = _descriptor.FieldDescriptor(
+    name='testgen_all', full_name='gogoproto.testgen_all', index=17,
+    number=63015, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+BENCHGEN_ALL_FIELD_NUMBER = 63016
+benchgen_all = _descriptor.FieldDescriptor(
+    name='benchgen_all', full_name='gogoproto.benchgen_all', index=18,
+    number=63016, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+MARSHALER_ALL_FIELD_NUMBER = 63017
+marshaler_all = _descriptor.FieldDescriptor(
+    name='marshaler_all', full_name='gogoproto.marshaler_all', index=19,
+    number=63017, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+UNMARSHALER_ALL_FIELD_NUMBER = 63018
+unmarshaler_all = _descriptor.FieldDescriptor(
+    name='unmarshaler_all', full_name='gogoproto.unmarshaler_all', index=20,
+    number=63018, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+STABLE_MARSHALER_ALL_FIELD_NUMBER = 63019
+stable_marshaler_all = _descriptor.FieldDescriptor(
+    name='stable_marshaler_all', full_name='gogoproto.stable_marshaler_all', index=21,
+    number=63019, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+SIZER_ALL_FIELD_NUMBER = 63020
+sizer_all = _descriptor.FieldDescriptor(
+    name='sizer_all', full_name='gogoproto.sizer_all', index=22,
+    number=63020, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+GOPROTO_ENUM_STRINGER_ALL_FIELD_NUMBER = 63021
+goproto_enum_stringer_all = _descriptor.FieldDescriptor(
+    name='goproto_enum_stringer_all', full_name='gogoproto.goproto_enum_stringer_all', index=23,
+    number=63021, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+ENUM_STRINGER_ALL_FIELD_NUMBER = 63022
+enum_stringer_all = _descriptor.FieldDescriptor(
+    name='enum_stringer_all', full_name='gogoproto.enum_stringer_all', index=24,
+    number=63022, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+UNSAFE_MARSHALER_ALL_FIELD_NUMBER = 63023
+unsafe_marshaler_all = _descriptor.FieldDescriptor(
+    name='unsafe_marshaler_all', full_name='gogoproto.unsafe_marshaler_all', index=25,
+    number=63023, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+UNSAFE_UNMARSHALER_ALL_FIELD_NUMBER = 63024
+unsafe_unmarshaler_all = _descriptor.FieldDescriptor(
+    name='unsafe_unmarshaler_all', full_name='gogoproto.unsafe_unmarshaler_all', index=26,
+    number=63024, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+GOPROTO_EXTENSIONS_MAP_ALL_FIELD_NUMBER = 63025
+goproto_extensions_map_all = _descriptor.FieldDescriptor(
+    name='goproto_extensions_map_all', full_name='gogoproto.goproto_extensions_map_all', index=27,
+    number=63025, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+GOPROTO_UNRECOGNIZED_ALL_FIELD_NUMBER = 63026
+goproto_unrecognized_all = _descriptor.FieldDescriptor(
+    name='goproto_unrecognized_all', full_name='gogoproto.goproto_unrecognized_all', index=28,
+    number=63026, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+GOGOPROTO_IMPORT_FIELD_NUMBER = 63027
+gogoproto_import = _descriptor.FieldDescriptor(
+    name='gogoproto_import', full_name='gogoproto.gogoproto_import', index=29,
+    number=63027, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+PROTOSIZER_ALL_FIELD_NUMBER = 63028
+protosizer_all = _descriptor.FieldDescriptor(
+    name='protosizer_all', full_name='gogoproto.protosizer_all', index=30,
+    number=63028, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+COMPARE_ALL_FIELD_NUMBER = 63029
+compare_all = _descriptor.FieldDescriptor(
+    name='compare_all', full_name='gogoproto.compare_all', index=31,
+    number=63029, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+TYPEDECL_ALL_FIELD_NUMBER = 63030
+typedecl_all = _descriptor.FieldDescriptor(
+    name='typedecl_all', full_name='gogoproto.typedecl_all', index=32,
+    number=63030, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+ENUMDECL_ALL_FIELD_NUMBER = 63031
+enumdecl_all = _descriptor.FieldDescriptor(
+    name='enumdecl_all', full_name='gogoproto.enumdecl_all', index=33,
+    number=63031, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+GOPROTO_REGISTRATION_FIELD_NUMBER = 63032
+goproto_registration = _descriptor.FieldDescriptor(
+    name='goproto_registration', full_name='gogoproto.goproto_registration', index=34,
+    number=63032, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+MESSAGENAME_ALL_FIELD_NUMBER = 63033
+messagename_all = _descriptor.FieldDescriptor(
+    name='messagename_all', full_name='gogoproto.messagename_all', index=35,
+    number=63033, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+GOPROTO_SIZECACHE_ALL_FIELD_NUMBER = 63034
+goproto_sizecache_all = _descriptor.FieldDescriptor(
+    name='goproto_sizecache_all', full_name='gogoproto.goproto_sizecache_all', index=36,
+    number=63034, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+GOPROTO_UNKEYED_ALL_FIELD_NUMBER = 63035
+goproto_unkeyed_all = _descriptor.FieldDescriptor(
+    name='goproto_unkeyed_all', full_name='gogoproto.goproto_unkeyed_all', index=37,
+    number=63035, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+GOPROTO_GETTERS_FIELD_NUMBER = 64001
+goproto_getters = _descriptor.FieldDescriptor(
+    name='goproto_getters', full_name='gogoproto.goproto_getters', index=38,
+    number=64001, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+GOPROTO_STRINGER_FIELD_NUMBER = 64003
+goproto_stringer = _descriptor.FieldDescriptor(
+    name='goproto_stringer', full_name='gogoproto.goproto_stringer', index=39,
+    number=64003, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+VERBOSE_EQUAL_FIELD_NUMBER = 64004
+verbose_equal = _descriptor.FieldDescriptor(
+    name='verbose_equal', full_name='gogoproto.verbose_equal', index=40,
+    number=64004, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+FACE_FIELD_NUMBER = 64005
+face = _descriptor.FieldDescriptor(
+    name='face', full_name='gogoproto.face', index=41,
+    number=64005, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+GOSTRING_FIELD_NUMBER = 64006
+gostring = _descriptor.FieldDescriptor(
+    name='gostring', full_name='gogoproto.gostring', index=42,
+    number=64006, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+POPULATE_FIELD_NUMBER = 64007
+populate = _descriptor.FieldDescriptor(
+    name='populate', full_name='gogoproto.populate', index=43,
+    number=64007, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+STRINGER_FIELD_NUMBER = 67008
+stringer = _descriptor.FieldDescriptor(
+    name='stringer', full_name='gogoproto.stringer', index=44,
+    number=67008, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+ONLYONE_FIELD_NUMBER = 64009
+onlyone = _descriptor.FieldDescriptor(
+    name='onlyone', full_name='gogoproto.onlyone', index=45,
+    number=64009, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+EQUAL_FIELD_NUMBER = 64013
+equal = _descriptor.FieldDescriptor(
+    name='equal', full_name='gogoproto.equal', index=46,
+    number=64013, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+DESCRIPTION_FIELD_NUMBER = 64014
+description = _descriptor.FieldDescriptor(
+    name='description', full_name='gogoproto.description', index=47,
+    number=64014, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+TESTGEN_FIELD_NUMBER = 64015
+testgen = _descriptor.FieldDescriptor(
+    name='testgen', full_name='gogoproto.testgen', index=48,
+    number=64015, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+BENCHGEN_FIELD_NUMBER = 64016
+benchgen = _descriptor.FieldDescriptor(
+    name='benchgen', full_name='gogoproto.benchgen', index=49,
+    number=64016, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+MARSHALER_FIELD_NUMBER = 64017
+marshaler = _descriptor.FieldDescriptor(
+    name='marshaler', full_name='gogoproto.marshaler', index=50,
+    number=64017, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+UNMARSHALER_FIELD_NUMBER = 64018
+unmarshaler = _descriptor.FieldDescriptor(
+    name='unmarshaler', full_name='gogoproto.unmarshaler', index=51,
+    number=64018, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+STABLE_MARSHALER_FIELD_NUMBER = 64019
+stable_marshaler = _descriptor.FieldDescriptor(
+    name='stable_marshaler', full_name='gogoproto.stable_marshaler', index=52,
+    number=64019, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+SIZER_FIELD_NUMBER = 64020
+sizer = _descriptor.FieldDescriptor(
+    name='sizer', full_name='gogoproto.sizer', index=53,
+    number=64020, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+UNSAFE_MARSHALER_FIELD_NUMBER = 64023
+unsafe_marshaler = _descriptor.FieldDescriptor(
+    name='unsafe_marshaler', full_name='gogoproto.unsafe_marshaler', index=54,
+    number=64023, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+UNSAFE_UNMARSHALER_FIELD_NUMBER = 64024
+unsafe_unmarshaler = _descriptor.FieldDescriptor(
+    name='unsafe_unmarshaler', full_name='gogoproto.unsafe_unmarshaler', index=55,
+    number=64024, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+GOPROTO_EXTENSIONS_MAP_FIELD_NUMBER = 64025
+goproto_extensions_map = _descriptor.FieldDescriptor(
+    name='goproto_extensions_map', full_name='gogoproto.goproto_extensions_map', index=56,
+    number=64025, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+GOPROTO_UNRECOGNIZED_FIELD_NUMBER = 64026
+goproto_unrecognized = _descriptor.FieldDescriptor(
+    name='goproto_unrecognized', full_name='gogoproto.goproto_unrecognized', index=57,
+    number=64026, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+PROTOSIZER_FIELD_NUMBER = 64028
+protosizer = _descriptor.FieldDescriptor(
+    name='protosizer', full_name='gogoproto.protosizer', index=58,
+    number=64028, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+COMPARE_FIELD_NUMBER = 64029
+compare = _descriptor.FieldDescriptor(
+    name='compare', full_name='gogoproto.compare', index=59,
+    number=64029, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+TYPEDECL_FIELD_NUMBER = 64030
+typedecl = _descriptor.FieldDescriptor(
+    name='typedecl', full_name='gogoproto.typedecl', index=60,
+    number=64030, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+MESSAGENAME_FIELD_NUMBER = 64033
+messagename = _descriptor.FieldDescriptor(
+    name='messagename', full_name='gogoproto.messagename', index=61,
+    number=64033, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+GOPROTO_SIZECACHE_FIELD_NUMBER = 64034
+goproto_sizecache = _descriptor.FieldDescriptor(
+    name='goproto_sizecache', full_name='gogoproto.goproto_sizecache', index=62,
+    number=64034, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+GOPROTO_UNKEYED_FIELD_NUMBER = 64035
+goproto_unkeyed = _descriptor.FieldDescriptor(
+    name='goproto_unkeyed', full_name='gogoproto.goproto_unkeyed', index=63,
+    number=64035, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+NULLABLE_FIELD_NUMBER = 65001
+nullable = _descriptor.FieldDescriptor(
+    name='nullable', full_name='gogoproto.nullable', index=64,
+    number=65001, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+EMBED_FIELD_NUMBER = 65002
+embed = _descriptor.FieldDescriptor(
+    name='embed', full_name='gogoproto.embed', index=65,
+    number=65002, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+CUSTOMTYPE_FIELD_NUMBER = 65003
+customtype = _descriptor.FieldDescriptor(
+    name='customtype', full_name='gogoproto.customtype', index=66,
+    number=65003, type=9, cpp_type=9, label=1,
+    has_default_value=False, default_value=b"".decode('utf-8'),
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+CUSTOMNAME_FIELD_NUMBER = 65004
+customname = _descriptor.FieldDescriptor(
+    name='customname', full_name='gogoproto.customname', index=67,
+    number=65004, type=9, cpp_type=9, label=1,
+    has_default_value=False, default_value=b"".decode('utf-8'),
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+JSONTAG_FIELD_NUMBER = 65005
+jsontag = _descriptor.FieldDescriptor(
+    name='jsontag', full_name='gogoproto.jsontag', index=68,
+    number=65005, type=9, cpp_type=9, label=1,
+    has_default_value=False, default_value=b"".decode('utf-8'),
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+MORETAGS_FIELD_NUMBER = 65006
+moretags = _descriptor.FieldDescriptor(
+    name='moretags', full_name='gogoproto.moretags', index=69,
+    number=65006, type=9, cpp_type=9, label=1,
+    has_default_value=False, default_value=b"".decode('utf-8'),
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+CASTTYPE_FIELD_NUMBER = 65007
+casttype = _descriptor.FieldDescriptor(
+    name='casttype', full_name='gogoproto.casttype', index=70,
+    number=65007, type=9, cpp_type=9, label=1,
+    has_default_value=False, default_value=b"".decode('utf-8'),
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+CASTKEY_FIELD_NUMBER = 65008
+castkey = _descriptor.FieldDescriptor(
+    name='castkey', full_name='gogoproto.castkey', index=71,
+    number=65008, type=9, cpp_type=9, label=1,
+    has_default_value=False, default_value=b"".decode('utf-8'),
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+CASTVALUE_FIELD_NUMBER = 65009
+castvalue = _descriptor.FieldDescriptor(
+    name='castvalue', full_name='gogoproto.castvalue', index=72,
+    number=65009, type=9, cpp_type=9, label=1,
+    has_default_value=False, default_value=b"".decode('utf-8'),
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+STDTIME_FIELD_NUMBER = 65010
+stdtime = _descriptor.FieldDescriptor(
+    name='stdtime', full_name='gogoproto.stdtime', index=73,
+    number=65010, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+STDDURATION_FIELD_NUMBER = 65011
+stdduration = _descriptor.FieldDescriptor(
+    name='stdduration', full_name='gogoproto.stdduration', index=74,
+    number=65011, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+WKTPOINTER_FIELD_NUMBER = 65012
+wktpointer = _descriptor.FieldDescriptor(
+    name='wktpointer', full_name='gogoproto.wktpointer', index=75,
+    number=65012, type=8, cpp_type=7, label=1,
+    has_default_value=False, default_value=False,
+    message_type=None, enum_type=None, containing_type=None,
+    is_extension=True, extension_scope=None,
+    serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key)
+
+DESCRIPTOR.extensions_by_name['goproto_enum_prefix'] = goproto_enum_prefix
+DESCRIPTOR.extensions_by_name['goproto_enum_stringer'] = goproto_enum_stringer
+DESCRIPTOR.extensions_by_name['enum_stringer'] = enum_stringer
+DESCRIPTOR.extensions_by_name['enum_customname'] = enum_customname
+DESCRIPTOR.extensions_by_name['enumdecl'] = enumdecl
+DESCRIPTOR.extensions_by_name['enumvalue_customname'] = enumvalue_customname
+DESCRIPTOR.extensions_by_name['goproto_getters_all'] = goproto_getters_all
+DESCRIPTOR.extensions_by_name['goproto_enum_prefix_all'] = goproto_enum_prefix_all
+DESCRIPTOR.extensions_by_name['goproto_stringer_all'] = goproto_stringer_all
+DESCRIPTOR.extensions_by_name['verbose_equal_all'] = verbose_equal_all
+DESCRIPTOR.extensions_by_name['face_all'] = face_all
+DESCRIPTOR.extensions_by_name['gostring_all'] = gostring_all
+DESCRIPTOR.extensions_by_name['populate_all'] = populate_all
+DESCRIPTOR.extensions_by_name['stringer_all'] = stringer_all
+DESCRIPTOR.extensions_by_name['onlyone_all'] = onlyone_all
+DESCRIPTOR.extensions_by_name['equal_all'] = equal_all
+DESCRIPTOR.extensions_by_name['description_all'] = description_all
+DESCRIPTOR.extensions_by_name['testgen_all'] = testgen_all
+DESCRIPTOR.extensions_by_name['benchgen_all'] = benchgen_all
+DESCRIPTOR.extensions_by_name['marshaler_all'] = marshaler_all
+DESCRIPTOR.extensions_by_name['unmarshaler_all'] = unmarshaler_all
+DESCRIPTOR.extensions_by_name['stable_marshaler_all'] = stable_marshaler_all
+DESCRIPTOR.extensions_by_name['sizer_all'] = sizer_all
+DESCRIPTOR.extensions_by_name['goproto_enum_stringer_all'] = goproto_enum_stringer_all
+DESCRIPTOR.extensions_by_name['enum_stringer_all'] = enum_stringer_all
+DESCRIPTOR.extensions_by_name['unsafe_marshaler_all'] = unsafe_marshaler_all
+DESCRIPTOR.extensions_by_name['unsafe_unmarshaler_all'] = unsafe_unmarshaler_all
+DESCRIPTOR.extensions_by_name['goproto_extensions_map_all'] = goproto_extensions_map_all
+DESCRIPTOR.extensions_by_name['goproto_unrecognized_all'] = goproto_unrecognized_all
+DESCRIPTOR.extensions_by_name['gogoproto_import'] = gogoproto_import
+DESCRIPTOR.extensions_by_name['protosizer_all'] = protosizer_all
+DESCRIPTOR.extensions_by_name['compare_all'] = compare_all
+DESCRIPTOR.extensions_by_name['typedecl_all'] = typedecl_all
+DESCRIPTOR.extensions_by_name['enumdecl_all'] = enumdecl_all
+DESCRIPTOR.extensions_by_name['goproto_registration'] = goproto_registration
+DESCRIPTOR.extensions_by_name['messagename_all'] = messagename_all
+DESCRIPTOR.extensions_by_name['goproto_sizecache_all'] = goproto_sizecache_all
+DESCRIPTOR.extensions_by_name['goproto_unkeyed_all'] = goproto_unkeyed_all
+DESCRIPTOR.extensions_by_name['goproto_getters'] = goproto_getters
+DESCRIPTOR.extensions_by_name['goproto_stringer'] = goproto_stringer
+DESCRIPTOR.extensions_by_name['verbose_equal'] = verbose_equal
+DESCRIPTOR.extensions_by_name['face'] = face
+DESCRIPTOR.extensions_by_name['gostring'] = gostring
+DESCRIPTOR.extensions_by_name['populate'] = populate
+DESCRIPTOR.extensions_by_name['stringer'] = stringer
+DESCRIPTOR.extensions_by_name['onlyone'] = onlyone
+DESCRIPTOR.extensions_by_name['equal'] = equal
+DESCRIPTOR.extensions_by_name['description'] = description
+DESCRIPTOR.extensions_by_name['testgen'] = testgen
+DESCRIPTOR.extensions_by_name['benchgen'] = benchgen
+DESCRIPTOR.extensions_by_name['marshaler'] = marshaler
+DESCRIPTOR.extensions_by_name['unmarshaler'] = unmarshaler
+DESCRIPTOR.extensions_by_name['stable_marshaler'] = stable_marshaler
+DESCRIPTOR.extensions_by_name['sizer'] = sizer
+DESCRIPTOR.extensions_by_name['unsafe_marshaler'] = unsafe_marshaler
+DESCRIPTOR.extensions_by_name['unsafe_unmarshaler'] = unsafe_unmarshaler
+DESCRIPTOR.extensions_by_name['goproto_extensions_map'] = goproto_extensions_map
+DESCRIPTOR.extensions_by_name['goproto_unrecognized'] = goproto_unrecognized
+DESCRIPTOR.extensions_by_name['protosizer'] = protosizer
+DESCRIPTOR.extensions_by_name['compare'] = compare
+DESCRIPTOR.extensions_by_name['typedecl'] = typedecl
+DESCRIPTOR.extensions_by_name['messagename'] = messagename
+DESCRIPTOR.extensions_by_name['goproto_sizecache'] = goproto_sizecache
+DESCRIPTOR.extensions_by_name['goproto_unkeyed'] = goproto_unkeyed
+DESCRIPTOR.extensions_by_name['nullable'] = nullable
+DESCRIPTOR.extensions_by_name['embed'] = embed
+DESCRIPTOR.extensions_by_name['customtype'] = customtype
+DESCRIPTOR.extensions_by_name['customname'] = customname
+DESCRIPTOR.extensions_by_name['jsontag'] = jsontag
+DESCRIPTOR.extensions_by_name['moretags'] = moretags
+DESCRIPTOR.extensions_by_name['casttype'] = casttype
+DESCRIPTOR.extensions_by_name['castkey'] = castkey
+DESCRIPTOR.extensions_by_name['castvalue'] = castvalue
+DESCRIPTOR.extensions_by_name['stdtime'] = stdtime
+DESCRIPTOR.extensions_by_name['stdduration'] = stdduration
+DESCRIPTOR.extensions_by_name['wktpointer'] = wktpointer
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+google_dot_protobuf_dot_descriptor__pb2.EnumOptions.RegisterExtension(goproto_enum_prefix)
+google_dot_protobuf_dot_descriptor__pb2.EnumOptions.RegisterExtension(goproto_enum_stringer)
+google_dot_protobuf_dot_descriptor__pb2.EnumOptions.RegisterExtension(enum_stringer)
+google_dot_protobuf_dot_descriptor__pb2.EnumOptions.RegisterExtension(enum_customname)
+google_dot_protobuf_dot_descriptor__pb2.EnumOptions.RegisterExtension(enumdecl)
+google_dot_protobuf_dot_descriptor__pb2.EnumValueOptions.RegisterExtension(enumvalue_customname)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(goproto_getters_all)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(goproto_enum_prefix_all)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(goproto_stringer_all)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(verbose_equal_all)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(face_all)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(gostring_all)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(populate_all)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(stringer_all)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(onlyone_all)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(equal_all)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(description_all)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(testgen_all)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(benchgen_all)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(marshaler_all)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(unmarshaler_all)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(stable_marshaler_all)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(sizer_all)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(goproto_enum_stringer_all)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(enum_stringer_all)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(unsafe_marshaler_all)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(unsafe_unmarshaler_all)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(goproto_extensions_map_all)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(goproto_unrecognized_all)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(gogoproto_import)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(protosizer_all)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(compare_all)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(typedecl_all)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(enumdecl_all)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(goproto_registration)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(messagename_all)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(goproto_sizecache_all)
+google_dot_protobuf_dot_descriptor__pb2.FileOptions.RegisterExtension(goproto_unkeyed_all)
+google_dot_protobuf_dot_descriptor__pb2.MessageOptions.RegisterExtension(goproto_getters)
+google_dot_protobuf_dot_descriptor__pb2.MessageOptions.RegisterExtension(goproto_stringer)
+google_dot_protobuf_dot_descriptor__pb2.MessageOptions.RegisterExtension(verbose_equal)
+google_dot_protobuf_dot_descriptor__pb2.MessageOptions.RegisterExtension(face)
+google_dot_protobuf_dot_descriptor__pb2.MessageOptions.RegisterExtension(gostring)
+google_dot_protobuf_dot_descriptor__pb2.MessageOptions.RegisterExtension(populate)
+google_dot_protobuf_dot_descriptor__pb2.MessageOptions.RegisterExtension(stringer)
+google_dot_protobuf_dot_descriptor__pb2.MessageOptions.RegisterExtension(onlyone)
+google_dot_protobuf_dot_descriptor__pb2.MessageOptions.RegisterExtension(equal)
+google_dot_protobuf_dot_descriptor__pb2.MessageOptions.RegisterExtension(description)
+google_dot_protobuf_dot_descriptor__pb2.MessageOptions.RegisterExtension(testgen)
+google_dot_protobuf_dot_descriptor__pb2.MessageOptions.RegisterExtension(benchgen)
+google_dot_protobuf_dot_descriptor__pb2.MessageOptions.RegisterExtension(marshaler)
+google_dot_protobuf_dot_descriptor__pb2.MessageOptions.RegisterExtension(unmarshaler)
+google_dot_protobuf_dot_descriptor__pb2.MessageOptions.RegisterExtension(stable_marshaler)
+google_dot_protobuf_dot_descriptor__pb2.MessageOptions.RegisterExtension(sizer)
+google_dot_protobuf_dot_descriptor__pb2.MessageOptions.RegisterExtension(unsafe_marshaler)
+google_dot_protobuf_dot_descriptor__pb2.MessageOptions.RegisterExtension(unsafe_unmarshaler)
+google_dot_protobuf_dot_descriptor__pb2.MessageOptions.RegisterExtension(goproto_extensions_map)
+google_dot_protobuf_dot_descriptor__pb2.MessageOptions.RegisterExtension(goproto_unrecognized)
+google_dot_protobuf_dot_descriptor__pb2.MessageOptions.RegisterExtension(protosizer)
+google_dot_protobuf_dot_descriptor__pb2.MessageOptions.RegisterExtension(compare)
+google_dot_protobuf_dot_descriptor__pb2.MessageOptions.RegisterExtension(typedecl)
+google_dot_protobuf_dot_descriptor__pb2.MessageOptions.RegisterExtension(messagename)
+google_dot_protobuf_dot_descriptor__pb2.MessageOptions.RegisterExtension(goproto_sizecache)
+google_dot_protobuf_dot_descriptor__pb2.MessageOptions.RegisterExtension(goproto_unkeyed)
+google_dot_protobuf_dot_descriptor__pb2.FieldOptions.RegisterExtension(nullable)
+google_dot_protobuf_dot_descriptor__pb2.FieldOptions.RegisterExtension(embed)
+google_dot_protobuf_dot_descriptor__pb2.FieldOptions.RegisterExtension(customtype)
+google_dot_protobuf_dot_descriptor__pb2.FieldOptions.RegisterExtension(customname)
+google_dot_protobuf_dot_descriptor__pb2.FieldOptions.RegisterExtension(jsontag)
+google_dot_protobuf_dot_descriptor__pb2.FieldOptions.RegisterExtension(moretags)
+google_dot_protobuf_dot_descriptor__pb2.FieldOptions.RegisterExtension(casttype)
+google_dot_protobuf_dot_descriptor__pb2.FieldOptions.RegisterExtension(castkey)
+google_dot_protobuf_dot_descriptor__pb2.FieldOptions.RegisterExtension(castvalue)
+google_dot_protobuf_dot_descriptor__pb2.FieldOptions.RegisterExtension(stdtime)
+google_dot_protobuf_dot_descriptor__pb2.FieldOptions.RegisterExtension(stdduration)
+google_dot_protobuf_dot_descriptor__pb2.FieldOptions.RegisterExtension(wktpointer)
+
+DESCRIPTOR._options = None
+# @@protoc_insertion_point(module_scope)
diff --git a/lark_channel/ws/pb/google/__init__.py b/lark_channel/ws/pb/google/__init__.py
new file mode 100644
index 0000000..d2d2a43
--- /dev/null
+++ b/lark_channel/ws/pb/google/__init__.py
@@ -0,0 +1,4 @@
+try:
+    __import__('pkg_resources').declare_namespace(__name__)
+except ImportError:
+    __path__ = __import__('pkgutil').extend_path(__path__, __name__)
diff --git a/lark_channel/ws/pb/google/protobuf/__init__.py b/lark_channel/ws/pb/google/protobuf/__init__.py
new file mode 100644
index 0000000..3087605
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/__init__.py
@@ -0,0 +1,33 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+# https://developers.google.com/protocol-buffers/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# Copyright 2007 Google Inc. All Rights Reserved.
+
+__version__ = '3.20.3'
diff --git a/lark_channel/ws/pb/google/protobuf/any_pb2.py b/lark_channel/ws/pb/google/protobuf/any_pb2.py
new file mode 100644
index 0000000..eccc99f
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/any_pb2.py
@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+# source: google/protobuf/any.proto
+"""Generated protocol buffer code."""
+from lark_channel.ws.pb.google.protobuf.internal import builder as _builder
+from lark_channel.ws.pb.google.protobuf import descriptor as _descriptor
+from lark_channel.ws.pb.google.protobuf import descriptor_pool as _descriptor_pool
+from lark_channel.ws.pb.google.protobuf import symbol_database as _symbol_database
+
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(
+    b'\n\x19google/protobuf/any.proto\x12\x0fgoogle.protobuf\"&\n\x03\x41ny\x12\x10\n\x08type_url\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x0c\x42v\n\x13\x63om.google.protobufB\x08\x41nyProtoP\x01Z,google.golang.org/protobuf/types/known/anypb\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesb\x06proto3')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.any_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+    DESCRIPTOR._options = None
+    DESCRIPTOR._serialized_options = b'\n\023com.google.protobufB\010AnyProtoP\001Z,google.golang.org/protobuf/types/known/anypb\242\002\003GPB\252\002\036Google.Protobuf.WellKnownTypes'
+    _ANY._serialized_start = 46
+    _ANY._serialized_end = 84
+# @@protoc_insertion_point(module_scope)
diff --git a/lark_channel/ws/pb/google/protobuf/api_pb2.py b/lark_channel/ws/pb/google/protobuf/api_pb2.py
new file mode 100644
index 0000000..4c7fed6
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/api_pb2.py
@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+# source: google/protobuf/api.proto
+"""Generated protocol buffer code."""
+from lark_channel.ws.pb.google.protobuf.internal import builder as _builder
+from lark_channel.ws.pb.google.protobuf import descriptor as _descriptor
+from lark_channel.ws.pb.google.protobuf import descriptor_pool as _descriptor_pool
+from lark_channel.ws.pb.google.protobuf import symbol_database as _symbol_database
+
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+from lark_channel.ws.pb.google.protobuf import source_context_pb2 as google_dot_protobuf_dot_source__context__pb2
+from lark_channel.ws.pb.google.protobuf import type_pb2 as google_dot_protobuf_dot_type__pb2
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(
+    b'\n\x19google/protobuf/api.proto\x12\x0fgoogle.protobuf\x1a$google/protobuf/source_context.proto\x1a\x1agoogle/protobuf/type.proto\"\x81\x02\n\x03\x41pi\x12\x0c\n\x04name\x18\x01 \x01(\t\x12(\n\x07methods\x18\x02 \x03(\x0b\x32\x17.google.protobuf.Method\x12(\n\x07options\x18\x03 \x03(\x0b\x32\x17.google.protobuf.Option\x12\x0f\n\x07version\x18\x04 \x01(\t\x12\x36\n\x0esource_context\x18\x05 \x01(\x0b\x32\x1e.google.protobuf.SourceContext\x12&\n\x06mixins\x18\x06 \x03(\x0b\x32\x16.google.protobuf.Mixin\x12\'\n\x06syntax\x18\x07 \x01(\x0e\x32\x17.google.protobuf.Syntax\"\xd5\x01\n\x06Method\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x18\n\x10request_type_url\x18\x02 \x01(\t\x12\x19\n\x11request_streaming\x18\x03 \x01(\x08\x12\x19\n\x11response_type_url\x18\x04 \x01(\t\x12\x1a\n\x12response_streaming\x18\x05 \x01(\x08\x12(\n\x07options\x18\x06 \x03(\x0b\x32\x17.google.protobuf.Option\x12\'\n\x06syntax\x18\x07 \x01(\x0e\x32\x17.google.protobuf.Syntax\"#\n\x05Mixin\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0c\n\x04root\x18\x02 \x01(\tBv\n\x13\x63om.google.protobufB\x08\x41piProtoP\x01Z,google.golang.org/protobuf/types/known/apipb\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesb\x06proto3')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.api_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+    DESCRIPTOR._options = None
+    DESCRIPTOR._serialized_options = b'\n\023com.google.protobufB\010ApiProtoP\001Z,google.golang.org/protobuf/types/known/apipb\242\002\003GPB\252\002\036Google.Protobuf.WellKnownTypes'
+    _API._serialized_start = 113
+    _API._serialized_end = 370
+    _METHOD._serialized_start = 373
+    _METHOD._serialized_end = 586
+    _MIXIN._serialized_start = 588
+    _MIXIN._serialized_end = 623
+# @@protoc_insertion_point(module_scope)
diff --git a/lark_channel/ws/pb/google/protobuf/compiler/__init__.py b/lark_channel/ws/pb/google/protobuf/compiler/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/lark_channel/ws/pb/google/protobuf/compiler/plugin_pb2.py b/lark_channel/ws/pb/google/protobuf/compiler/plugin_pb2.py
new file mode 100644
index 0000000..8368321
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/compiler/plugin_pb2.py
@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+# source: google/protobuf/compiler/plugin.proto
+"""Generated protocol buffer code."""
+from lark_channel.ws.pb.google.protobuf.internal import builder as _builder
+from lark_channel.ws.pb.google.protobuf import descriptor as _descriptor
+from lark_channel.ws.pb.google.protobuf import descriptor_pool as _descriptor_pool
+from lark_channel.ws.pb.google.protobuf import symbol_database as _symbol_database
+
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+from lark_channel.ws.pb.google.protobuf import descriptor_pb2 as google_dot_protobuf_dot_descriptor__pb2
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(
+    b'\n%google/protobuf/compiler/plugin.proto\x12\x18google.protobuf.compiler\x1a google/protobuf/descriptor.proto\"F\n\x07Version\x12\r\n\x05major\x18\x01 \x01(\x05\x12\r\n\x05minor\x18\x02 \x01(\x05\x12\r\n\x05patch\x18\x03 \x01(\x05\x12\x0e\n\x06suffix\x18\x04 \x01(\t\"\xba\x01\n\x14\x43odeGeneratorRequest\x12\x18\n\x10\x66ile_to_generate\x18\x01 \x03(\t\x12\x11\n\tparameter\x18\x02 \x01(\t\x12\x38\n\nproto_file\x18\x0f \x03(\x0b\x32$.google.protobuf.FileDescriptorProto\x12;\n\x10\x63ompiler_version\x18\x03 \x01(\x0b\x32!.google.protobuf.compiler.Version\"\xc1\x02\n\x15\x43odeGeneratorResponse\x12\r\n\x05\x65rror\x18\x01 \x01(\t\x12\x1a\n\x12supported_features\x18\x02 \x01(\x04\x12\x42\n\x04\x66ile\x18\x0f \x03(\x0b\x32\x34.google.protobuf.compiler.CodeGeneratorResponse.File\x1a\x7f\n\x04\x46ile\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x17\n\x0finsertion_point\x18\x02 \x01(\t\x12\x0f\n\x07\x63ontent\x18\x0f \x01(\t\x12?\n\x13generated_code_info\x18\x10 \x01(\x0b\x32\".google.protobuf.GeneratedCodeInfo\"8\n\x07\x46\x65\x61ture\x12\x10\n\x0c\x46\x45\x41TURE_NONE\x10\x00\x12\x1b\n\x17\x46\x45\x41TURE_PROTO3_OPTIONAL\x10\x01\x42W\n\x1c\x63om.google.protobuf.compilerB\x0cPluginProtosZ)google.golang.org/protobuf/types/pluginpb')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.compiler.plugin_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+    DESCRIPTOR._options = None
+    DESCRIPTOR._serialized_options = b'\n\034com.google.protobuf.compilerB\014PluginProtosZ)google.golang.org/protobuf/types/pluginpb'
+    _VERSION._serialized_start = 101
+    _VERSION._serialized_end = 171
+    _CODEGENERATORREQUEST._serialized_start = 174
+    _CODEGENERATORREQUEST._serialized_end = 360
+    _CODEGENERATORRESPONSE._serialized_start = 363
+    _CODEGENERATORRESPONSE._serialized_end = 684
+    _CODEGENERATORRESPONSE_FILE._serialized_start = 499
+    _CODEGENERATORRESPONSE_FILE._serialized_end = 626
+    _CODEGENERATORRESPONSE_FEATURE._serialized_start = 628
+    _CODEGENERATORRESPONSE_FEATURE._serialized_end = 684
+# @@protoc_insertion_point(module_scope)
diff --git a/lark_channel/ws/pb/google/protobuf/descriptor.py b/lark_channel/ws/pb/google/protobuf/descriptor.py
new file mode 100644
index 0000000..03c0cf5
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/descriptor.py
@@ -0,0 +1,1217 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+# https://developers.google.com/protocol-buffers/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""Descriptors essentially contain exactly the information found in a .proto
+file, in types that make this information accessible in Python.
+"""
+
+__author__ = 'robinson@google.com (Will Robinson)'
+
+import threading
+import warnings
+
+from lark_channel.ws.pb.google.protobuf.internal import api_implementation
+
+_USE_C_DESCRIPTORS = False
+if api_implementation.Type() == 'cpp':
+    # Used by MakeDescriptor in cpp mode
+    import binascii
+    import os
+    from lark_channel.ws.pb.google.protobuf.pyext import _message
+
+    _USE_C_DESCRIPTORS = True
+
+
+class Error(Exception):
+    """Base error for this module."""
+
+
+class TypeTransformationError(Error):
+    """Error transforming between python proto type and corresponding C++ type."""
+
+
+if _USE_C_DESCRIPTORS:
+    # This metaclass allows to override the behavior of code like
+    #     isinstance(my_descriptor, FieldDescriptor)
+    # and make it return True when the descriptor is an instance of the extension
+    # type written in C++.
+    class DescriptorMetaclass(type):
+        def __instancecheck__(cls, obj):
+            if super(DescriptorMetaclass, cls).__instancecheck__(obj):
+                return True
+            if isinstance(obj, cls._C_DESCRIPTOR_CLASS):
+                return True
+            return False
+else:
+    # The standard metaclass; nothing changes.
+    DescriptorMetaclass = type
+
+
+class _Lock(object):
+    """Wrapper class of threading.Lock(), which is allowed by 'with'."""
+
+    def __new__(cls):
+        self = object.__new__(cls)
+        self._lock = threading.Lock()  # pylint: disable=protected-access
+        return self
+
+    def __enter__(self):
+        self._lock.acquire()
+
+    def __exit__(self, exc_type, exc_value, exc_tb):
+        self._lock.release()
+
+
+_lock = threading.Lock()
+
+
+def _Deprecated(name):
+    if _Deprecated.count > 0:
+        _Deprecated.count -= 1
+        warnings.warn(
+            'Call to deprecated create function %s(). Note: Create unlinked '
+            'descriptors is going to go away. Please use get/find descriptors from '
+            'generated code or query the descriptor_pool.'
+            % name,
+            category=DeprecationWarning, stacklevel=3)
+
+
+# Deprecated warnings will print 100 times at most which should be enough for
+# users to notice and do not cause timeout.
+_Deprecated.count = 100
+
+_internal_create_key = object()
+
+
+class DescriptorBase(metaclass=DescriptorMetaclass):
+    """Descriptors base class.
+
+    This class is the base of all descriptor classes. It provides common options
+    related functionality.
+
+    Attributes:
+      has_options:  True if the descriptor has non-default options.  Usually it
+          is not necessary to read this -- just call GetOptions() which will
+          happily return the default instance.  However, it's sometimes useful
+          for efficiency, and also useful inside the protobuf implementation to
+          avoid some bootstrapping issues.
+    """
+
+    if _USE_C_DESCRIPTORS:
+        # The class, or tuple of classes, that are considered as "virtual
+        # subclasses" of this descriptor class.
+        _C_DESCRIPTOR_CLASS = ()
+
+    def __init__(self, options, serialized_options, options_class_name):
+        """Initialize the descriptor given its options message and the name of the
+        class of the options message. The name of the class is required in case
+        the options message is None and has to be created.
+        """
+        self._options = options
+        self._options_class_name = options_class_name
+        self._serialized_options = serialized_options
+
+        # Does this descriptor have non-default options?
+        self.has_options = (options is not None) or (serialized_options is not None)
+
+    def _SetOptions(self, options, options_class_name):
+        """Sets the descriptor's options
+
+        This function is used in generated proto2 files to update descriptor
+        options. It must not be used outside proto2.
+        """
+        self._options = options
+        self._options_class_name = options_class_name
+
+        # Does this descriptor have non-default options?
+        self.has_options = options is not None
+
+    def GetOptions(self):
+        """Retrieves descriptor options.
+
+        This method returns the options set or creates the default options for the
+        descriptor.
+        """
+        if self._options:
+            return self._options
+
+        from lark_channel.ws.pb.google.protobuf import descriptor_pb2
+        try:
+            options_class = getattr(descriptor_pb2,
+                                    self._options_class_name)
+        except AttributeError:
+            raise RuntimeError('Unknown options class name %s!' %
+                               (self._options_class_name))
+
+        with _lock:
+            if self._serialized_options is None:
+                self._options = options_class()
+            else:
+                self._options = _ParseOptions(options_class(),
+                                              self._serialized_options)
+
+            return self._options
+
+
+class _NestedDescriptorBase(DescriptorBase):
+    """Common class for descriptors that can be nested."""
+
+    def __init__(self, options, options_class_name, name, full_name,
+                 file, containing_type, serialized_start=None,
+                 serialized_end=None, serialized_options=None):
+        """Constructor.
+
+        Args:
+          options: Protocol message options or None
+            to use default message options.
+          options_class_name (str): The class name of the above options.
+          name (str): Name of this protocol message type.
+          full_name (str): Fully-qualified name of this protocol message type,
+            which will include protocol "package" name and the name of any
+            enclosing types.
+          file (FileDescriptor): Reference to file info.
+          containing_type: if provided, this is a nested descriptor, with this
+            descriptor as parent, otherwise None.
+          serialized_start: The start index (inclusive) in block in the
+            file.serialized_pb that describes this descriptor.
+          serialized_end: The end index (exclusive) in block in the
+            file.serialized_pb that describes this descriptor.
+          serialized_options: Protocol message serialized options or None.
+        """
+        super(_NestedDescriptorBase, self).__init__(
+            options, serialized_options, options_class_name)
+
+        self.name = name
+        # TODO(falk): Add function to calculate full_name instead of having it in
+        #             memory?
+        self.full_name = full_name
+        self.file = file
+        self.containing_type = containing_type
+
+        self._serialized_start = serialized_start
+        self._serialized_end = serialized_end
+
+    def CopyToProto(self, proto):
+        """Copies this to the matching proto in descriptor_pb2.
+
+        Args:
+          proto: An empty proto instance from descriptor_pb2.
+
+        Raises:
+          Error: If self couldn't be serialized, due to to few constructor
+            arguments.
+        """
+        if (self.file is not None and
+                self._serialized_start is not None and
+                self._serialized_end is not None):
+            proto.ParseFromString(self.file.serialized_pb[
+                                  self._serialized_start:self._serialized_end])
+        else:
+            raise Error('Descriptor does not contain serialization.')
+
+
+class Descriptor(_NestedDescriptorBase):
+    """Descriptor for a protocol message type.
+
+    Attributes:
+        name (str): Name of this protocol message type.
+        full_name (str): Fully-qualified name of this protocol message type,
+            which will include protocol "package" name and the name of any
+            enclosing types.
+        containing_type (Descriptor): Reference to the descriptor of the type
+            containing us, or None if this is top-level.
+        fields (list[FieldDescriptor]): Field descriptors for all fields in
+            this type.
+        fields_by_number (dict(int, FieldDescriptor)): Same
+            :class:`FieldDescriptor` objects as in :attr:`fields`, but indexed
+            by "number" attribute in each FieldDescriptor.
+        fields_by_name (dict(str, FieldDescriptor)): Same
+            :class:`FieldDescriptor` objects as in :attr:`fields`, but indexed by
+            "name" attribute in each :class:`FieldDescriptor`.
+        nested_types (list[Descriptor]): Descriptor references
+            for all protocol message types nested within this one.
+        nested_types_by_name (dict(str, Descriptor)): Same Descriptor
+            objects as in :attr:`nested_types`, but indexed by "name" attribute
+            in each Descriptor.
+        enum_types (list[EnumDescriptor]): :class:`EnumDescriptor` references
+            for all enums contained within this type.
+        enum_types_by_name (dict(str, EnumDescriptor)): Same
+            :class:`EnumDescriptor` objects as in :attr:`enum_types`, but
+            indexed by "name" attribute in each EnumDescriptor.
+        enum_values_by_name (dict(str, EnumValueDescriptor)): Dict mapping
+            from enum value name to :class:`EnumValueDescriptor` for that value.
+        extensions (list[FieldDescriptor]): All extensions defined directly
+            within this message type (NOT within a nested type).
+        extensions_by_name (dict(str, FieldDescriptor)): Same FieldDescriptor
+            objects as :attr:`extensions`, but indexed by "name" attribute of each
+            FieldDescriptor.
+        is_extendable (bool):  Does this type define any extension ranges?
+        oneofs (list[OneofDescriptor]): The list of descriptors for oneof fields
+            in this message.
+        oneofs_by_name (dict(str, OneofDescriptor)): Same objects as in
+            :attr:`oneofs`, but indexed by "name" attribute.
+        file (FileDescriptor): Reference to file descriptor.
+
+    """
+
+    if _USE_C_DESCRIPTORS:
+        _C_DESCRIPTOR_CLASS = _message.Descriptor
+
+        def __new__(
+                cls,
+                name=None,
+                full_name=None,
+                filename=None,
+                containing_type=None,
+                fields=None,
+                nested_types=None,
+                enum_types=None,
+                extensions=None,
+                options=None,
+                serialized_options=None,
+                is_extendable=True,
+                extension_ranges=None,
+                oneofs=None,
+                file=None,  # pylint: disable=redefined-builtin
+                serialized_start=None,
+                serialized_end=None,
+                syntax=None,
+                create_key=None):
+            _message.Message._CheckCalledFromGeneratedFile()
+            return _message.default_pool.FindMessageTypeByName(full_name)
+
+    # NOTE(tmarek): The file argument redefining a builtin is nothing we can
+    # fix right now since we don't know how many clients already rely on the
+    # name of the argument.
+    def __init__(self, name, full_name, filename, containing_type, fields,
+                 nested_types, enum_types, extensions, options=None,
+                 serialized_options=None,
+                 is_extendable=True, extension_ranges=None, oneofs=None,
+                 file=None, serialized_start=None, serialized_end=None,  # pylint: disable=redefined-builtin
+                 syntax=None, create_key=None):
+        """Arguments to __init__() are as described in the description
+        of Descriptor fields above.
+
+        Note that filename is an obsolete argument, that is not used anymore.
+        Please use file.name to access this as an attribute.
+        """
+        if create_key is not _internal_create_key:
+            _Deprecated('Descriptor')
+
+        super(Descriptor, self).__init__(
+            options, 'MessageOptions', name, full_name, file,
+            containing_type, serialized_start=serialized_start,
+            serialized_end=serialized_end, serialized_options=serialized_options)
+
+        # We have fields in addition to fields_by_name and fields_by_number,
+        # so that:
+        #   1. Clients can index fields by "order in which they're listed."
+        #   2. Clients can easily iterate over all fields with the terse
+        #      syntax: for f in descriptor.fields: ...
+        self.fields = fields
+        for field in self.fields:
+            field.containing_type = self
+        self.fields_by_number = dict((f.number, f) for f in fields)
+        self.fields_by_name = dict((f.name, f) for f in fields)
+        self._fields_by_camelcase_name = None
+
+        self.nested_types = nested_types
+        for nested_type in nested_types:
+            nested_type.containing_type = self
+        self.nested_types_by_name = dict((t.name, t) for t in nested_types)
+
+        self.enum_types = enum_types
+        for enum_type in self.enum_types:
+            enum_type.containing_type = self
+        self.enum_types_by_name = dict((t.name, t) for t in enum_types)
+        self.enum_values_by_name = dict(
+            (v.name, v) for t in enum_types for v in t.values)
+
+        self.extensions = extensions
+        for extension in self.extensions:
+            extension.extension_scope = self
+        self.extensions_by_name = dict((f.name, f) for f in extensions)
+        self.is_extendable = is_extendable
+        self.extension_ranges = extension_ranges
+        self.oneofs = oneofs if oneofs is not None else []
+        self.oneofs_by_name = dict((o.name, o) for o in self.oneofs)
+        for oneof in self.oneofs:
+            oneof.containing_type = self
+        self.syntax = syntax or "proto2"
+
+    @property
+    def fields_by_camelcase_name(self):
+        """Same FieldDescriptor objects as in :attr:`fields`, but indexed by
+        :attr:`FieldDescriptor.camelcase_name`.
+        """
+        if self._fields_by_camelcase_name is None:
+            self._fields_by_camelcase_name = dict(
+                (f.camelcase_name, f) for f in self.fields)
+        return self._fields_by_camelcase_name
+
+    def EnumValueName(self, enum, value):
+        """Returns the string name of an enum value.
+
+        This is just a small helper method to simplify a common operation.
+
+        Args:
+          enum: string name of the Enum.
+          value: int, value of the enum.
+
+        Returns:
+          string name of the enum value.
+
+        Raises:
+          KeyError if either the Enum doesn't exist or the value is not a valid
+            value for the enum.
+        """
+        return self.enum_types_by_name[enum].values_by_number[value].name
+
+    def CopyToProto(self, proto):
+        """Copies this to a descriptor_pb2.DescriptorProto.
+
+        Args:
+          proto: An empty descriptor_pb2.DescriptorProto.
+        """
+        # This function is overridden to give a better doc comment.
+        super(Descriptor, self).CopyToProto(proto)
+
+
+# TODO(robinson): We should have aggressive checking here,
+# for example:
+#   * If you specify a repeated field, you should not be allowed
+#     to specify a default value.
+#   * [Other examples here as needed].
+#
+# TODO(robinson): for this and other *Descriptor classes, we
+# might also want to lock things down aggressively (e.g.,
+# prevent clients from setting the attributes).  Having
+# stronger invariants here in general will reduce the number
+# of runtime checks we must do in reflection.py...
+class FieldDescriptor(DescriptorBase):
+    """Descriptor for a single field in a .proto file.
+
+    Attributes:
+      name (str): Name of this field, exactly as it appears in .proto.
+      full_name (str): Name of this field, including containing scope.  This is
+        particularly relevant for extensions.
+      index (int): Dense, 0-indexed index giving the order that this
+        field textually appears within its message in the .proto file.
+      number (int): Tag number declared for this field in the .proto file.
+
+      type (int): (One of the TYPE_* constants below) Declared type.
+      cpp_type (int): (One of the CPPTYPE_* constants below) C++ type used to
+        represent this field.
+
+      label (int): (One of the LABEL_* constants below) Tells whether this
+        field is optional, required, or repeated.
+      has_default_value (bool): True if this field has a default value defined,
+        otherwise false.
+      default_value (Varies): Default value of this field.  Only
+        meaningful for non-repeated scalar fields.  Repeated fields
+        should always set this to [], and non-repeated composite
+        fields should always set this to None.
+
+      containing_type (Descriptor): Descriptor of the protocol message
+        type that contains this field.  Set by the Descriptor constructor
+        if we're passed into one.
+        Somewhat confusingly, for extension fields, this is the
+        descriptor of the EXTENDED message, not the descriptor
+        of the message containing this field.  (See is_extension and
+        extension_scope below).
+      message_type (Descriptor): If a composite field, a descriptor
+        of the message type contained in this field.  Otherwise, this is None.
+      enum_type (EnumDescriptor): If this field contains an enum, a
+        descriptor of that enum.  Otherwise, this is None.
+
+      is_extension: True iff this describes an extension field.
+      extension_scope (Descriptor): Only meaningful if is_extension is True.
+        Gives the message that immediately contains this extension field.
+        Will be None iff we're a top-level (file-level) extension field.
+
+      options (descriptor_pb2.FieldOptions): Protocol message field options or
+        None to use default field options.
+
+      containing_oneof (OneofDescriptor): If the field is a member of a oneof
+        union, contains its descriptor. Otherwise, None.
+
+      file (FileDescriptor): Reference to file descriptor.
+    """
+
+    # Must be consistent with C++ FieldDescriptor::Type enum in
+    # descriptor.h.
+    #
+    # TODO(robinson): Find a way to eliminate this repetition.
+    TYPE_DOUBLE = 1
+    TYPE_FLOAT = 2
+    TYPE_INT64 = 3
+    TYPE_UINT64 = 4
+    TYPE_INT32 = 5
+    TYPE_FIXED64 = 6
+    TYPE_FIXED32 = 7
+    TYPE_BOOL = 8
+    TYPE_STRING = 9
+    TYPE_GROUP = 10
+    TYPE_MESSAGE = 11
+    TYPE_BYTES = 12
+    TYPE_UINT32 = 13
+    TYPE_ENUM = 14
+    TYPE_SFIXED32 = 15
+    TYPE_SFIXED64 = 16
+    TYPE_SINT32 = 17
+    TYPE_SINT64 = 18
+    MAX_TYPE = 18
+
+    # Must be consistent with C++ FieldDescriptor::CppType enum in
+    # descriptor.h.
+    #
+    # TODO(robinson): Find a way to eliminate this repetition.
+    CPPTYPE_INT32 = 1
+    CPPTYPE_INT64 = 2
+    CPPTYPE_UINT32 = 3
+    CPPTYPE_UINT64 = 4
+    CPPTYPE_DOUBLE = 5
+    CPPTYPE_FLOAT = 6
+    CPPTYPE_BOOL = 7
+    CPPTYPE_ENUM = 8
+    CPPTYPE_STRING = 9
+    CPPTYPE_MESSAGE = 10
+    MAX_CPPTYPE = 10
+
+    _PYTHON_TO_CPP_PROTO_TYPE_MAP = {
+        TYPE_DOUBLE: CPPTYPE_DOUBLE,
+        TYPE_FLOAT: CPPTYPE_FLOAT,
+        TYPE_ENUM: CPPTYPE_ENUM,
+        TYPE_INT64: CPPTYPE_INT64,
+        TYPE_SINT64: CPPTYPE_INT64,
+        TYPE_SFIXED64: CPPTYPE_INT64,
+        TYPE_UINT64: CPPTYPE_UINT64,
+        TYPE_FIXED64: CPPTYPE_UINT64,
+        TYPE_INT32: CPPTYPE_INT32,
+        TYPE_SFIXED32: CPPTYPE_INT32,
+        TYPE_SINT32: CPPTYPE_INT32,
+        TYPE_UINT32: CPPTYPE_UINT32,
+        TYPE_FIXED32: CPPTYPE_UINT32,
+        TYPE_BYTES: CPPTYPE_STRING,
+        TYPE_STRING: CPPTYPE_STRING,
+        TYPE_BOOL: CPPTYPE_BOOL,
+        TYPE_MESSAGE: CPPTYPE_MESSAGE,
+        TYPE_GROUP: CPPTYPE_MESSAGE
+    }
+
+    # Must be consistent with C++ FieldDescriptor::Label enum in
+    # descriptor.h.
+    #
+    # TODO(robinson): Find a way to eliminate this repetition.
+    LABEL_OPTIONAL = 1
+    LABEL_REQUIRED = 2
+    LABEL_REPEATED = 3
+    MAX_LABEL = 3
+
+    # Must be consistent with C++ constants kMaxNumber, kFirstReservedNumber,
+    # and kLastReservedNumber in descriptor.h
+    MAX_FIELD_NUMBER = (1 << 29) - 1
+    FIRST_RESERVED_FIELD_NUMBER = 19000
+    LAST_RESERVED_FIELD_NUMBER = 19999
+
+    if _USE_C_DESCRIPTORS:
+        _C_DESCRIPTOR_CLASS = _message.FieldDescriptor
+
+        def __new__(cls, name, full_name, index, number, type, cpp_type, label,
+                    default_value, message_type, enum_type, containing_type,
+                    is_extension, extension_scope, options=None,
+                    serialized_options=None,
+                    has_default_value=True, containing_oneof=None, json_name=None,
+                    file=None, create_key=None):  # pylint: disable=redefined-builtin
+            _message.Message._CheckCalledFromGeneratedFile()
+            if is_extension:
+                return _message.default_pool.FindExtensionByName(full_name)
+            else:
+                return _message.default_pool.FindFieldByName(full_name)
+
+    def __init__(self, name, full_name, index, number, type, cpp_type, label,
+                 default_value, message_type, enum_type, containing_type,
+                 is_extension, extension_scope, options=None,
+                 serialized_options=None,
+                 has_default_value=True, containing_oneof=None, json_name=None,
+                 file=None, create_key=None):  # pylint: disable=redefined-builtin
+        """The arguments are as described in the description of FieldDescriptor
+        attributes above.
+
+        Note that containing_type may be None, and may be set later if necessary
+        (to deal with circular references between message types, for example).
+        Likewise for extension_scope.
+        """
+        if create_key is not _internal_create_key:
+            _Deprecated('FieldDescriptor')
+
+        super(FieldDescriptor, self).__init__(
+            options, serialized_options, 'FieldOptions')
+        self.name = name
+        self.full_name = full_name
+        self.file = file
+        self._camelcase_name = None
+        if json_name is None:
+            self.json_name = _ToJsonName(name)
+        else:
+            self.json_name = json_name
+        self.index = index
+        self.number = number
+        self.type = type
+        self.cpp_type = cpp_type
+        self.label = label
+        self.has_default_value = has_default_value
+        self.default_value = default_value
+        self.containing_type = containing_type
+        self.message_type = message_type
+        self.enum_type = enum_type
+        self.is_extension = is_extension
+        self.extension_scope = extension_scope
+        self.containing_oneof = containing_oneof
+        if api_implementation.Type() == 'cpp':
+            if is_extension:
+                self._cdescriptor = _message.default_pool.FindExtensionByName(full_name)
+            else:
+                self._cdescriptor = _message.default_pool.FindFieldByName(full_name)
+        else:
+            self._cdescriptor = None
+
+    @property
+    def camelcase_name(self):
+        """Camelcase name of this field.
+
+        Returns:
+          str: the name in CamelCase.
+        """
+        if self._camelcase_name is None:
+            self._camelcase_name = _ToCamelCase(self.name)
+        return self._camelcase_name
+
+    @property
+    def has_presence(self):
+        """Whether the field distinguishes between unpopulated and default values.
+
+        Raises:
+          RuntimeError: singular field that is not linked with message nor file.
+        """
+        if self.label == FieldDescriptor.LABEL_REPEATED:
+            return False
+        if (self.cpp_type == FieldDescriptor.CPPTYPE_MESSAGE or
+                self.containing_oneof):
+            return True
+        if hasattr(self.file, 'syntax'):
+            return self.file.syntax == 'proto2'
+        if hasattr(self.message_type, 'syntax'):
+            return self.message_type.syntax == 'proto2'
+        raise RuntimeError(
+            'has_presence is not ready to use because field %s is not'
+            ' linked with message type nor file' % self.full_name)
+
+    @staticmethod
+    def ProtoTypeToCppProtoType(proto_type):
+        """Converts from a Python proto type to a C++ Proto Type.
+
+        The Python ProtocolBuffer classes specify both the 'Python' datatype and the
+        'C++' datatype - and they're not the same. This helper method should
+        translate from one to another.
+
+        Args:
+          proto_type: the Python proto type (descriptor.FieldDescriptor.TYPE_*)
+        Returns:
+          int: descriptor.FieldDescriptor.CPPTYPE_*, the C++ type.
+        Raises:
+          TypeTransformationError: when the Python proto type isn't known.
+        """
+        try:
+            return FieldDescriptor._PYTHON_TO_CPP_PROTO_TYPE_MAP[proto_type]
+        except KeyError:
+            raise TypeTransformationError('Unknown proto_type: %s' % proto_type)
+
+
+class EnumDescriptor(_NestedDescriptorBase):
+    """Descriptor for an enum defined in a .proto file.
+
+    Attributes:
+      name (str): Name of the enum type.
+      full_name (str): Full name of the type, including package name
+        and any enclosing type(s).
+
+      values (list[EnumValueDescriptor]): List of the values
+        in this enum.
+      values_by_name (dict(str, EnumValueDescriptor)): Same as :attr:`values`,
+        but indexed by the "name" field of each EnumValueDescriptor.
+      values_by_number (dict(int, EnumValueDescriptor)): Same as :attr:`values`,
+        but indexed by the "number" field of each EnumValueDescriptor.
+      containing_type (Descriptor): Descriptor of the immediate containing
+        type of this enum, or None if this is an enum defined at the
+        top level in a .proto file.  Set by Descriptor's constructor
+        if we're passed into one.
+      file (FileDescriptor): Reference to file descriptor.
+      options (descriptor_pb2.EnumOptions): Enum options message or
+        None to use default enum options.
+    """
+
+    if _USE_C_DESCRIPTORS:
+        _C_DESCRIPTOR_CLASS = _message.EnumDescriptor
+
+        def __new__(cls, name, full_name, filename, values,
+                    containing_type=None, options=None,
+                    serialized_options=None, file=None,  # pylint: disable=redefined-builtin
+                    serialized_start=None, serialized_end=None, create_key=None):
+            _message.Message._CheckCalledFromGeneratedFile()
+            return _message.default_pool.FindEnumTypeByName(full_name)
+
+    def __init__(self, name, full_name, filename, values,
+                 containing_type=None, options=None,
+                 serialized_options=None, file=None,  # pylint: disable=redefined-builtin
+                 serialized_start=None, serialized_end=None, create_key=None):
+        """Arguments are as described in the attribute description above.
+
+        Note that filename is an obsolete argument, that is not used anymore.
+        Please use file.name to access this as an attribute.
+        """
+        if create_key is not _internal_create_key:
+            _Deprecated('EnumDescriptor')
+
+        super(EnumDescriptor, self).__init__(
+            options, 'EnumOptions', name, full_name, file,
+            containing_type, serialized_start=serialized_start,
+            serialized_end=serialized_end, serialized_options=serialized_options)
+
+        self.values = values
+        for value in self.values:
+            value.type = self
+        self.values_by_name = dict((v.name, v) for v in values)
+        # Values are reversed to ensure that the first alias is retained.
+        self.values_by_number = dict((v.number, v) for v in reversed(values))
+
+    def CopyToProto(self, proto):
+        """Copies this to a descriptor_pb2.EnumDescriptorProto.
+
+        Args:
+          proto (descriptor_pb2.EnumDescriptorProto): An empty descriptor proto.
+        """
+        # This function is overridden to give a better doc comment.
+        super(EnumDescriptor, self).CopyToProto(proto)
+
+
+class EnumValueDescriptor(DescriptorBase):
+    """Descriptor for a single value within an enum.
+
+    Attributes:
+      name (str): Name of this value.
+      index (int): Dense, 0-indexed index giving the order that this
+        value appears textually within its enum in the .proto file.
+      number (int): Actual number assigned to this enum value.
+      type (EnumDescriptor): :class:`EnumDescriptor` to which this value
+        belongs.  Set by :class:`EnumDescriptor`'s constructor if we're
+        passed into one.
+      options (descriptor_pb2.EnumValueOptions): Enum value options message or
+        None to use default enum value options options.
+    """
+
+    if _USE_C_DESCRIPTORS:
+        _C_DESCRIPTOR_CLASS = _message.EnumValueDescriptor
+
+        def __new__(cls, name, index, number,
+                    type=None,  # pylint: disable=redefined-builtin
+                    options=None, serialized_options=None, create_key=None):
+            _message.Message._CheckCalledFromGeneratedFile()
+            # There is no way we can build a complete EnumValueDescriptor with the
+            # given parameters (the name of the Enum is not known, for example).
+            # Fortunately generated files just pass it to the EnumDescriptor()
+            # constructor, which will ignore it, so returning None is good enough.
+            return None
+
+    def __init__(self, name, index, number,
+                 type=None,  # pylint: disable=redefined-builtin
+                 options=None, serialized_options=None, create_key=None):
+        """Arguments are as described in the attribute description above."""
+        if create_key is not _internal_create_key:
+            _Deprecated('EnumValueDescriptor')
+
+        super(EnumValueDescriptor, self).__init__(
+            options, serialized_options, 'EnumValueOptions')
+        self.name = name
+        self.index = index
+        self.number = number
+        self.type = type
+
+
+class OneofDescriptor(DescriptorBase):
+    """Descriptor for a oneof field.
+
+    Attributes:
+      name (str): Name of the oneof field.
+      full_name (str): Full name of the oneof field, including package name.
+      index (int): 0-based index giving the order of the oneof field inside
+        its containing type.
+      containing_type (Descriptor): :class:`Descriptor` of the protocol message
+        type that contains this field.  Set by the :class:`Descriptor` constructor
+        if we're passed into one.
+      fields (list[FieldDescriptor]): The list of field descriptors this
+        oneof can contain.
+    """
+
+    if _USE_C_DESCRIPTORS:
+        _C_DESCRIPTOR_CLASS = _message.OneofDescriptor
+
+        def __new__(
+                cls, name, full_name, index, containing_type, fields, options=None,
+                serialized_options=None, create_key=None):
+            _message.Message._CheckCalledFromGeneratedFile()
+            return _message.default_pool.FindOneofByName(full_name)
+
+    def __init__(
+            self, name, full_name, index, containing_type, fields, options=None,
+            serialized_options=None, create_key=None):
+        """Arguments are as described in the attribute description above."""
+        if create_key is not _internal_create_key:
+            _Deprecated('OneofDescriptor')
+
+        super(OneofDescriptor, self).__init__(
+            options, serialized_options, 'OneofOptions')
+        self.name = name
+        self.full_name = full_name
+        self.index = index
+        self.containing_type = containing_type
+        self.fields = fields
+
+
+class ServiceDescriptor(_NestedDescriptorBase):
+    """Descriptor for a service.
+
+    Attributes:
+      name (str): Name of the service.
+      full_name (str): Full name of the service, including package name.
+      index (int): 0-indexed index giving the order that this services
+        definition appears within the .proto file.
+      methods (list[MethodDescriptor]): List of methods provided by this
+        service.
+      methods_by_name (dict(str, MethodDescriptor)): Same
+        :class:`MethodDescriptor` objects as in :attr:`methods_by_name`, but
+        indexed by "name" attribute in each :class:`MethodDescriptor`.
+      options (descriptor_pb2.ServiceOptions): Service options message or
+        None to use default service options.
+      file (FileDescriptor): Reference to file info.
+    """
+
+    if _USE_C_DESCRIPTORS:
+        _C_DESCRIPTOR_CLASS = _message.ServiceDescriptor
+
+        def __new__(
+                cls,
+                name=None,
+                full_name=None,
+                index=None,
+                methods=None,
+                options=None,
+                serialized_options=None,
+                file=None,  # pylint: disable=redefined-builtin
+                serialized_start=None,
+                serialized_end=None,
+                create_key=None):
+            _message.Message._CheckCalledFromGeneratedFile()  # pylint: disable=protected-access
+            return _message.default_pool.FindServiceByName(full_name)
+
+    def __init__(self, name, full_name, index, methods, options=None,
+                 serialized_options=None, file=None,  # pylint: disable=redefined-builtin
+                 serialized_start=None, serialized_end=None, create_key=None):
+        if create_key is not _internal_create_key:
+            _Deprecated('ServiceDescriptor')
+
+        super(ServiceDescriptor, self).__init__(
+            options, 'ServiceOptions', name, full_name, file,
+            None, serialized_start=serialized_start,
+            serialized_end=serialized_end, serialized_options=serialized_options)
+        self.index = index
+        self.methods = methods
+        self.methods_by_name = dict((m.name, m) for m in methods)
+        # Set the containing service for each method in this service.
+        for method in self.methods:
+            method.containing_service = self
+
+    def FindMethodByName(self, name):
+        """Searches for the specified method, and returns its descriptor.
+
+        Args:
+          name (str): Name of the method.
+        Returns:
+          MethodDescriptor or None: the descriptor for the requested method, if
+          found.
+        """
+        return self.methods_by_name.get(name, None)
+
+    def CopyToProto(self, proto):
+        """Copies this to a descriptor_pb2.ServiceDescriptorProto.
+
+        Args:
+          proto (descriptor_pb2.ServiceDescriptorProto): An empty descriptor proto.
+        """
+        # This function is overridden to give a better doc comment.
+        super(ServiceDescriptor, self).CopyToProto(proto)
+
+
+class MethodDescriptor(DescriptorBase):
+    """Descriptor for a method in a service.
+
+    Attributes:
+      name (str): Name of the method within the service.
+      full_name (str): Full name of method.
+      index (int): 0-indexed index of the method inside the service.
+      containing_service (ServiceDescriptor): The service that contains this
+        method.
+      input_type (Descriptor): The descriptor of the message that this method
+        accepts.
+      output_type (Descriptor): The descriptor of the message that this method
+        returns.
+      client_streaming (bool): Whether this method uses client streaming.
+      server_streaming (bool): Whether this method uses server streaming.
+      options (descriptor_pb2.MethodOptions or None): Method options message, or
+        None to use default method options.
+    """
+
+    if _USE_C_DESCRIPTORS:
+        _C_DESCRIPTOR_CLASS = _message.MethodDescriptor
+
+        def __new__(cls,
+                    name,
+                    full_name,
+                    index,
+                    containing_service,
+                    input_type,
+                    output_type,
+                    client_streaming=False,
+                    server_streaming=False,
+                    options=None,
+                    serialized_options=None,
+                    create_key=None):
+            _message.Message._CheckCalledFromGeneratedFile()  # pylint: disable=protected-access
+            return _message.default_pool.FindMethodByName(full_name)
+
+    def __init__(self,
+                 name,
+                 full_name,
+                 index,
+                 containing_service,
+                 input_type,
+                 output_type,
+                 client_streaming=False,
+                 server_streaming=False,
+                 options=None,
+                 serialized_options=None,
+                 create_key=None):
+        """The arguments are as described in the description of MethodDescriptor
+        attributes above.
+
+        Note that containing_service may be None, and may be set later if necessary.
+        """
+        if create_key is not _internal_create_key:
+            _Deprecated('MethodDescriptor')
+
+        super(MethodDescriptor, self).__init__(
+            options, serialized_options, 'MethodOptions')
+        self.name = name
+        self.full_name = full_name
+        self.index = index
+        self.containing_service = containing_service
+        self.input_type = input_type
+        self.output_type = output_type
+        self.client_streaming = client_streaming
+        self.server_streaming = server_streaming
+
+    def CopyToProto(self, proto):
+        """Copies this to a descriptor_pb2.MethodDescriptorProto.
+
+        Args:
+          proto (descriptor_pb2.MethodDescriptorProto): An empty descriptor proto.
+
+        Raises:
+          Error: If self couldn't be serialized, due to too few constructor
+            arguments.
+        """
+        if self.containing_service is not None:
+            from lark_channel.ws.pb.google.protobuf import descriptor_pb2
+            service_proto = descriptor_pb2.ServiceDescriptorProto()
+            self.containing_service.CopyToProto(service_proto)
+            proto.CopyFrom(service_proto.method[self.index])
+        else:
+            raise Error('Descriptor does not contain a service.')
+
+
+class FileDescriptor(DescriptorBase):
+    """Descriptor for a file. Mimics the descriptor_pb2.FileDescriptorProto.
+
+    Note that :attr:`enum_types_by_name`, :attr:`extensions_by_name`, and
+    :attr:`dependencies` fields are only set by the
+    :py:mod:`google.protobuf.message_factory` module, and not by the generated
+    proto code.
+
+    Attributes:
+      name (str): Name of file, relative to root of source tree.
+      package (str): Name of the package
+      syntax (str): string indicating syntax of the file (can be "proto2" or
+        "proto3")
+      serialized_pb (bytes): Byte string of serialized
+        :class:`descriptor_pb2.FileDescriptorProto`.
+      dependencies (list[FileDescriptor]): List of other :class:`FileDescriptor`
+        objects this :class:`FileDescriptor` depends on.
+      public_dependencies (list[FileDescriptor]): A subset of
+        :attr:`dependencies`, which were declared as "public".
+      message_types_by_name (dict(str, Descriptor)): Mapping from message names
+        to their :class:`Descriptor`.
+      enum_types_by_name (dict(str, EnumDescriptor)): Mapping from enum names to
+        their :class:`EnumDescriptor`.
+      extensions_by_name (dict(str, FieldDescriptor)): Mapping from extension
+        names declared at file scope to their :class:`FieldDescriptor`.
+      services_by_name (dict(str, ServiceDescriptor)): Mapping from services'
+        names to their :class:`ServiceDescriptor`.
+      pool (DescriptorPool): The pool this descriptor belongs to.  When not
+        passed to the constructor, the global default pool is used.
+    """
+
+    if _USE_C_DESCRIPTORS:
+        _C_DESCRIPTOR_CLASS = _message.FileDescriptor
+
+        def __new__(cls, name, package, options=None,
+                    serialized_options=None, serialized_pb=None,
+                    dependencies=None, public_dependencies=None,
+                    syntax=None, pool=None, create_key=None):
+            # FileDescriptor() is called from various places, not only from generated
+            # files, to register dynamic proto files and messages.
+            # pylint: disable=g-explicit-bool-comparison
+            if serialized_pb == b'':
+                # Cpp generated code must be linked in if serialized_pb is ''
+                try:
+                    return _message.default_pool.FindFileByName(name)
+                except KeyError:
+                    raise RuntimeError('Please link in cpp generated lib for %s' % (name))
+            elif serialized_pb:
+                return _message.default_pool.AddSerializedFile(serialized_pb)
+            else:
+                return super(FileDescriptor, cls).__new__(cls)
+
+    def __init__(self, name, package, options=None,
+                 serialized_options=None, serialized_pb=None,
+                 dependencies=None, public_dependencies=None,
+                 syntax=None, pool=None, create_key=None):
+        """Constructor."""
+        if create_key is not _internal_create_key:
+            _Deprecated('FileDescriptor')
+
+        super(FileDescriptor, self).__init__(
+            options, serialized_options, 'FileOptions')
+
+        if pool is None:
+            from lark_channel.ws.pb.google.protobuf import descriptor_pool
+            pool = descriptor_pool.Default()
+        self.pool = pool
+        self.message_types_by_name = {}
+        self.name = name
+        self.package = package
+        self.syntax = syntax or "proto2"
+        self.serialized_pb = serialized_pb
+
+        self.enum_types_by_name = {}
+        self.extensions_by_name = {}
+        self.services_by_name = {}
+        self.dependencies = (dependencies or [])
+        self.public_dependencies = (public_dependencies or [])
+
+    def CopyToProto(self, proto):
+        """Copies this to a descriptor_pb2.FileDescriptorProto.
+
+        Args:
+          proto: An empty descriptor_pb2.FileDescriptorProto.
+        """
+        proto.ParseFromString(self.serialized_pb)
+
+
+def _ParseOptions(message, string):
+    """Parses serialized options.
+
+    This helper function is used to parse serialized options in generated
+    proto2 files. It must not be used outside proto2.
+    """
+    message.ParseFromString(string)
+    return message
+
+
+def _ToCamelCase(name):
+    """Converts name to camel-case and returns it."""
+    capitalize_next = False
+    result = []
+
+    for c in name:
+        if c == '_':
+            if result:
+                capitalize_next = True
+        elif capitalize_next:
+            result.append(c.upper())
+            capitalize_next = False
+        else:
+            result += c
+
+    # Lower-case the first letter.
+    if result and result[0].isupper():
+        result[0] = result[0].lower()
+    return ''.join(result)
+
+
+def _OptionsOrNone(descriptor_proto):
+    """Returns the value of the field `options`, or None if it is not set."""
+    if descriptor_proto.HasField('options'):
+        return descriptor_proto.options
+    else:
+        return None
+
+
+def _ToJsonName(name):
+    """Converts name to Json name and returns it."""
+    capitalize_next = False
+    result = []
+
+    for c in name:
+        if c == '_':
+            capitalize_next = True
+        elif capitalize_next:
+            result.append(c.upper())
+            capitalize_next = False
+        else:
+            result += c
+
+    return ''.join(result)
+
+
+def MakeDescriptor(desc_proto, package='', build_file_if_cpp=True,
+                   syntax=None):
+    """Make a protobuf Descriptor given a DescriptorProto protobuf.
+
+    Handles nested descriptors. Note that this is limited to the scope of defining
+    a message inside of another message. Composite fields can currently only be
+    resolved if the message is defined in the same scope as the field.
+
+    Args:
+      desc_proto: The descriptor_pb2.DescriptorProto protobuf message.
+      package: Optional package name for the new message Descriptor (string).
+      build_file_if_cpp: Update the C++ descriptor pool if api matches.
+                         Set to False on recursion, so no duplicates are created.
+      syntax: The syntax/semantics that should be used.  Set to "proto3" to get
+              proto3 field presence semantics.
+    Returns:
+      A Descriptor for protobuf messages.
+    """
+    if api_implementation.Type() == 'cpp' and build_file_if_cpp:
+        # The C++ implementation requires all descriptors to be backed by the same
+        # definition in the C++ descriptor pool. To do this, we build a
+        # FileDescriptorProto with the same definition as this descriptor and build
+        # it into the pool.
+        from lark_channel.ws.pb.google.protobuf import descriptor_pb2
+        file_descriptor_proto = descriptor_pb2.FileDescriptorProto()
+        file_descriptor_proto.message_type.add().MergeFrom(desc_proto)
+
+        # Generate a random name for this proto file to prevent conflicts with any
+        # imported ones. We need to specify a file name so the descriptor pool
+        # accepts our FileDescriptorProto, but it is not important what that file
+        # name is actually set to.
+        proto_name = binascii.hexlify(os.urandom(16)).decode('ascii')
+
+        if package:
+            file_descriptor_proto.name = os.path.join(package.replace('.', '/'),
+                                                      proto_name + '.proto')
+            file_descriptor_proto.package = package
+        else:
+            file_descriptor_proto.name = proto_name + '.proto'
+
+        _message.default_pool.Add(file_descriptor_proto)
+        result = _message.default_pool.FindFileByName(file_descriptor_proto.name)
+
+        if _USE_C_DESCRIPTORS:
+            return result.message_types_by_name[desc_proto.name]
+
+    full_message_name = [desc_proto.name]
+    if package: full_message_name.insert(0, package)
+
+    # Create Descriptors for enum types
+    enum_types = {}
+    for enum_proto in desc_proto.enum_type:
+        full_name = '.'.join(full_message_name + [enum_proto.name])
+        enum_desc = EnumDescriptor(
+            enum_proto.name, full_name, None, [
+                EnumValueDescriptor(enum_val.name, ii, enum_val.number,
+                                    create_key=_internal_create_key)
+                for ii, enum_val in enumerate(enum_proto.value)],
+            create_key=_internal_create_key)
+        enum_types[full_name] = enum_desc
+
+    # Create Descriptors for nested types
+    nested_types = {}
+    for nested_proto in desc_proto.nested_type:
+        full_name = '.'.join(full_message_name + [nested_proto.name])
+        # Nested types are just those defined inside of the message, not all types
+        # used by fields in the message, so no loops are possible here.
+        nested_desc = MakeDescriptor(nested_proto,
+                                     package='.'.join(full_message_name),
+                                     build_file_if_cpp=False,
+                                     syntax=syntax)
+        nested_types[full_name] = nested_desc
+
+    fields = []
+    for field_proto in desc_proto.field:
+        full_name = '.'.join(full_message_name + [field_proto.name])
+        enum_desc = None
+        nested_desc = None
+        if field_proto.json_name:
+            json_name = field_proto.json_name
+        else:
+            json_name = None
+        if field_proto.HasField('type_name'):
+            type_name = field_proto.type_name
+            full_type_name = '.'.join(full_message_name +
+                                      [type_name[type_name.rfind('.') + 1:]])
+            if full_type_name in nested_types:
+                nested_desc = nested_types[full_type_name]
+            elif full_type_name in enum_types:
+                enum_desc = enum_types[full_type_name]
+            # Else type_name references a non-local type, which isn't implemented
+        field = FieldDescriptor(
+            field_proto.name, full_name, field_proto.number - 1,
+            field_proto.number, field_proto.type,
+            FieldDescriptor.ProtoTypeToCppProtoType(field_proto.type),
+            field_proto.label, None, nested_desc, enum_desc, None, False, None,
+            options=_OptionsOrNone(field_proto), has_default_value=False,
+            json_name=json_name, create_key=_internal_create_key)
+        fields.append(field)
+
+    desc_name = '.'.join(full_message_name)
+    return Descriptor(desc_proto.name, desc_name, None, None, fields,
+                      list(nested_types.values()), list(enum_types.values()), [],
+                      options=_OptionsOrNone(desc_proto),
+                      create_key=_internal_create_key)
diff --git a/lark_channel/ws/pb/google/protobuf/descriptor_database.py b/lark_channel/ws/pb/google/protobuf/descriptor_database.py
new file mode 100644
index 0000000..09cea81
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/descriptor_database.py
@@ -0,0 +1,177 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+# https://developers.google.com/protocol-buffers/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""Provides a container for DescriptorProtos."""
+
+__author__ = 'matthewtoia@google.com (Matt Toia)'
+
+import warnings
+
+
+class Error(Exception):
+    pass
+
+
+class DescriptorDatabaseConflictingDefinitionError(Error):
+    """Raised when a proto is added with the same name & different descriptor."""
+
+
+class DescriptorDatabase(object):
+    """A container accepting FileDescriptorProtos and maps DescriptorProtos."""
+
+    def __init__(self):
+        self._file_desc_protos_by_file = {}
+        self._file_desc_protos_by_symbol = {}
+
+    def Add(self, file_desc_proto):
+        """Adds the FileDescriptorProto and its types to this database.
+
+        Args:
+          file_desc_proto: The FileDescriptorProto to add.
+        Raises:
+          DescriptorDatabaseConflictingDefinitionError: if an attempt is made to
+            add a proto with the same name but different definition than an
+            existing proto in the database.
+        """
+        proto_name = file_desc_proto.name
+        if proto_name not in self._file_desc_protos_by_file:
+            self._file_desc_protos_by_file[proto_name] = file_desc_proto
+        elif self._file_desc_protos_by_file[proto_name] != file_desc_proto:
+            raise DescriptorDatabaseConflictingDefinitionError(
+                '%s already added, but with different descriptor.' % proto_name)
+        else:
+            return
+
+        # Add all the top-level descriptors to the index.
+        package = file_desc_proto.package
+        for message in file_desc_proto.message_type:
+            for name in _ExtractSymbols(message, package):
+                self._AddSymbol(name, file_desc_proto)
+        for enum in file_desc_proto.enum_type:
+            self._AddSymbol(('.'.join((package, enum.name))), file_desc_proto)
+            for enum_value in enum.value:
+                self._file_desc_protos_by_symbol[
+                    '.'.join((package, enum_value.name))] = file_desc_proto
+        for extension in file_desc_proto.extension:
+            self._AddSymbol(('.'.join((package, extension.name))), file_desc_proto)
+        for service in file_desc_proto.service:
+            self._AddSymbol(('.'.join((package, service.name))), file_desc_proto)
+
+    def FindFileByName(self, name):
+        """Finds the file descriptor proto by file name.
+
+        Typically the file name is a relative path ending to a .proto file. The
+        proto with the given name will have to have been added to this database
+        using the Add method or else an error will be raised.
+
+        Args:
+          name: The file name to find.
+
+        Returns:
+          The file descriptor proto matching the name.
+
+        Raises:
+          KeyError if no file by the given name was added.
+        """
+
+        return self._file_desc_protos_by_file[name]
+
+    def FindFileContainingSymbol(self, symbol):
+        """Finds the file descriptor proto containing the specified symbol.
+
+        The symbol should be a fully qualified name including the file descriptor's
+        package and any containing messages. Some examples:
+
+        'some.package.name.Message'
+        'some.package.name.Message.NestedEnum'
+        'some.package.name.Message.some_field'
+
+        The file descriptor proto containing the specified symbol must be added to
+        this database using the Add method or else an error will be raised.
+
+        Args:
+          symbol: The fully qualified symbol name.
+
+        Returns:
+          The file descriptor proto containing the symbol.
+
+        Raises:
+          KeyError if no file contains the specified symbol.
+        """
+        try:
+            return self._file_desc_protos_by_symbol[symbol]
+        except KeyError:
+            # Fields, enum values, and nested extensions are not in
+            # _file_desc_protos_by_symbol. Try to find the top level
+            # descriptor. Non-existent nested symbol under a valid top level
+            # descriptor can also be found. The behavior is the same with
+            # protobuf C++.
+            top_level, _, _ = symbol.rpartition('.')
+            try:
+                return self._file_desc_protos_by_symbol[top_level]
+            except KeyError:
+                # Raise the original symbol as a KeyError for better diagnostics.
+                raise KeyError(symbol)
+
+    def FindFileContainingExtension(self, extendee_name, extension_number):
+        # TODO(jieluo): implement this API.
+        return None
+
+    def FindAllExtensionNumbers(self, extendee_name):
+        # TODO(jieluo): implement this API.
+        return []
+
+    def _AddSymbol(self, name, file_desc_proto):
+        if name in self._file_desc_protos_by_symbol:
+            warn_msg = ('Conflict register for file "' + file_desc_proto.name +
+                        '": ' + name +
+                        ' is already defined in file "' +
+                        self._file_desc_protos_by_symbol[name].name + '"')
+            warnings.warn(warn_msg, RuntimeWarning)
+        self._file_desc_protos_by_symbol[name] = file_desc_proto
+
+
+def _ExtractSymbols(desc_proto, package):
+    """Pulls out all the symbols from a descriptor proto.
+
+    Args:
+      desc_proto: The proto to extract symbols from.
+      package: The package containing the descriptor type.
+
+    Yields:
+      The fully qualified name found in the descriptor.
+    """
+    message_name = package + '.' + desc_proto.name if package else desc_proto.name
+    yield message_name
+    for nested_type in desc_proto.nested_type:
+        for symbol in _ExtractSymbols(nested_type, message_name):
+            yield symbol
+    for enum_type in desc_proto.enum_type:
+        yield '.'.join((message_name, enum_type.name))
diff --git a/lark_channel/ws/pb/google/protobuf/descriptor_pb2.py b/lark_channel/ws/pb/google/protobuf/descriptor_pb2.py
new file mode 100644
index 0000000..7f93538
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/descriptor_pb2.py
@@ -0,0 +1,1907 @@
+# -*- coding: utf-8 -*-
+# source: google/protobuf/descriptor.proto
+"""Generated protocol buffer code."""
+from lark_channel.ws.pb.google.protobuf.internal import builder as _builder
+from lark_channel.ws.pb.google.protobuf import descriptor as _descriptor
+from lark_channel.ws.pb.google.protobuf import descriptor_pool as _descriptor_pool
+from lark_channel.ws.pb.google.protobuf import symbol_database as _symbol_database
+
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+if _descriptor._USE_C_DESCRIPTORS == False:
+    DESCRIPTOR = _descriptor.FileDescriptor(
+        name='google/protobuf/descriptor.proto',
+        package='google.protobuf',
+        syntax='proto2',
+        serialized_options=None,
+        create_key=_descriptor._internal_create_key,
+        serialized_pb=b'\n google/protobuf/descriptor.proto\x12\x0fgoogle.protobuf\"G\n\x11\x46ileDescriptorSet\x12\x32\n\x04\x66ile\x18\x01 \x03(\x0b\x32$.google.protobuf.FileDescriptorProto\"\xdb\x03\n\x13\x46ileDescriptorProto\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0f\n\x07package\x18\x02 \x01(\t\x12\x12\n\ndependency\x18\x03 \x03(\t\x12\x19\n\x11public_dependency\x18\n \x03(\x05\x12\x17\n\x0fweak_dependency\x18\x0b \x03(\x05\x12\x36\n\x0cmessage_type\x18\x04 \x03(\x0b\x32 .google.protobuf.DescriptorProto\x12\x37\n\tenum_type\x18\x05 \x03(\x0b\x32$.google.protobuf.EnumDescriptorProto\x12\x38\n\x07service\x18\x06 \x03(\x0b\x32\'.google.protobuf.ServiceDescriptorProto\x12\x38\n\textension\x18\x07 \x03(\x0b\x32%.google.protobuf.FieldDescriptorProto\x12-\n\x07options\x18\x08 \x01(\x0b\x32\x1c.google.protobuf.FileOptions\x12\x39\n\x10source_code_info\x18\t \x01(\x0b\x32\x1f.google.protobuf.SourceCodeInfo\x12\x0e\n\x06syntax\x18\x0c \x01(\t\"\xa9\x05\n\x0f\x44\x65scriptorProto\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x34\n\x05\x66ield\x18\x02 \x03(\x0b\x32%.google.protobuf.FieldDescriptorProto\x12\x38\n\textension\x18\x06 \x03(\x0b\x32%.google.protobuf.FieldDescriptorProto\x12\x35\n\x0bnested_type\x18\x03 \x03(\x0b\x32 .google.protobuf.DescriptorProto\x12\x37\n\tenum_type\x18\x04 \x03(\x0b\x32$.google.protobuf.EnumDescriptorProto\x12H\n\x0f\x65xtension_range\x18\x05 \x03(\x0b\x32/.google.protobuf.DescriptorProto.ExtensionRange\x12\x39\n\noneof_decl\x18\x08 \x03(\x0b\x32%.google.protobuf.OneofDescriptorProto\x12\x30\n\x07options\x18\x07 \x01(\x0b\x32\x1f.google.protobuf.MessageOptions\x12\x46\n\x0ereserved_range\x18\t \x03(\x0b\x32..google.protobuf.DescriptorProto.ReservedRange\x12\x15\n\rreserved_name\x18\n \x03(\t\x1a\x65\n\x0e\x45xtensionRange\x12\r\n\x05start\x18\x01 \x01(\x05\x12\x0b\n\x03\x65nd\x18\x02 \x01(\x05\x12\x37\n\x07options\x18\x03 \x01(\x0b\x32&.google.protobuf.ExtensionRangeOptions\x1a+\n\rReservedRange\x12\r\n\x05start\x18\x01 \x01(\x05\x12\x0b\n\x03\x65nd\x18\x02 \x01(\x05\"g\n\x15\x45xtensionRangeOptions\x12\x43\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOption*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\"\xd5\x05\n\x14\x46ieldDescriptorProto\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0e\n\x06number\x18\x03 \x01(\x05\x12:\n\x05label\x18\x04 \x01(\x0e\x32+.google.protobuf.FieldDescriptorProto.Label\x12\x38\n\x04type\x18\x05 \x01(\x0e\x32*.google.protobuf.FieldDescriptorProto.Type\x12\x11\n\ttype_name\x18\x06 \x01(\t\x12\x10\n\x08\x65xtendee\x18\x02 \x01(\t\x12\x15\n\rdefault_value\x18\x07 \x01(\t\x12\x13\n\x0boneof_index\x18\t \x01(\x05\x12\x11\n\tjson_name\x18\n \x01(\t\x12.\n\x07options\x18\x08 \x01(\x0b\x32\x1d.google.protobuf.FieldOptions\x12\x17\n\x0fproto3_optional\x18\x11 \x01(\x08\"\xb6\x02\n\x04Type\x12\x0f\n\x0bTYPE_DOUBLE\x10\x01\x12\x0e\n\nTYPE_FLOAT\x10\x02\x12\x0e\n\nTYPE_INT64\x10\x03\x12\x0f\n\x0bTYPE_UINT64\x10\x04\x12\x0e\n\nTYPE_INT32\x10\x05\x12\x10\n\x0cTYPE_FIXED64\x10\x06\x12\x10\n\x0cTYPE_FIXED32\x10\x07\x12\r\n\tTYPE_BOOL\x10\x08\x12\x0f\n\x0bTYPE_STRING\x10\t\x12\x0e\n\nTYPE_GROUP\x10\n\x12\x10\n\x0cTYPE_MESSAGE\x10\x0b\x12\x0e\n\nTYPE_BYTES\x10\x0c\x12\x0f\n\x0bTYPE_UINT32\x10\r\x12\r\n\tTYPE_ENUM\x10\x0e\x12\x11\n\rTYPE_SFIXED32\x10\x0f\x12\x11\n\rTYPE_SFIXED64\x10\x10\x12\x0f\n\x0bTYPE_SINT32\x10\x11\x12\x0f\n\x0bTYPE_SINT64\x10\x12\"C\n\x05Label\x12\x12\n\x0eLABEL_OPTIONAL\x10\x01\x12\x12\n\x0eLABEL_REQUIRED\x10\x02\x12\x12\n\x0eLABEL_REPEATED\x10\x03\"T\n\x14OneofDescriptorProto\x12\x0c\n\x04name\x18\x01 \x01(\t\x12.\n\x07options\x18\x02 \x01(\x0b\x32\x1d.google.protobuf.OneofOptions\"\xa4\x02\n\x13\x45numDescriptorProto\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x38\n\x05value\x18\x02 \x03(\x0b\x32).google.protobuf.EnumValueDescriptorProto\x12-\n\x07options\x18\x03 \x01(\x0b\x32\x1c.google.protobuf.EnumOptions\x12N\n\x0ereserved_range\x18\x04 \x03(\x0b\x32\x36.google.protobuf.EnumDescriptorProto.EnumReservedRange\x12\x15\n\rreserved_name\x18\x05 \x03(\t\x1a/\n\x11\x45numReservedRange\x12\r\n\x05start\x18\x01 \x01(\x05\x12\x0b\n\x03\x65nd\x18\x02 \x01(\x05\"l\n\x18\x45numValueDescriptorProto\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0e\n\x06number\x18\x02 \x01(\x05\x12\x32\n\x07options\x18\x03 \x01(\x0b\x32!.google.protobuf.EnumValueOptions\"\x90\x01\n\x16ServiceDescriptorProto\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x36\n\x06method\x18\x02 \x03(\x0b\x32&.google.protobuf.MethodDescriptorProto\x12\x30\n\x07options\x18\x03 \x01(\x0b\x32\x1f.google.protobuf.ServiceOptions\"\xc1\x01\n\x15MethodDescriptorProto\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x12\n\ninput_type\x18\x02 \x01(\t\x12\x13\n\x0boutput_type\x18\x03 \x01(\t\x12/\n\x07options\x18\x04 \x01(\x0b\x32\x1e.google.protobuf.MethodOptions\x12\x1f\n\x10\x63lient_streaming\x18\x05 \x01(\x08:\x05\x66\x61lse\x12\x1f\n\x10server_streaming\x18\x06 \x01(\x08:\x05\x66\x61lse\"\xa5\x06\n\x0b\x46ileOptions\x12\x14\n\x0cjava_package\x18\x01 \x01(\t\x12\x1c\n\x14java_outer_classname\x18\x08 \x01(\t\x12\"\n\x13java_multiple_files\x18\n \x01(\x08:\x05\x66\x61lse\x12)\n\x1djava_generate_equals_and_hash\x18\x14 \x01(\x08\x42\x02\x18\x01\x12%\n\x16java_string_check_utf8\x18\x1b \x01(\x08:\x05\x66\x61lse\x12\x46\n\x0coptimize_for\x18\t \x01(\x0e\x32).google.protobuf.FileOptions.OptimizeMode:\x05SPEED\x12\x12\n\ngo_package\x18\x0b \x01(\t\x12\"\n\x13\x63\x63_generic_services\x18\x10 \x01(\x08:\x05\x66\x61lse\x12$\n\x15java_generic_services\x18\x11 \x01(\x08:\x05\x66\x61lse\x12\"\n\x13py_generic_services\x18\x12 \x01(\x08:\x05\x66\x61lse\x12#\n\x14php_generic_services\x18* \x01(\x08:\x05\x66\x61lse\x12\x19\n\ndeprecated\x18\x17 \x01(\x08:\x05\x66\x61lse\x12\x1e\n\x10\x63\x63_enable_arenas\x18\x1f \x01(\x08:\x04true\x12\x19\n\x11objc_class_prefix\x18$ \x01(\t\x12\x18\n\x10\x63sharp_namespace\x18% \x01(\t\x12\x14\n\x0cswift_prefix\x18\' \x01(\t\x12\x18\n\x10php_class_prefix\x18( \x01(\t\x12\x15\n\rphp_namespace\x18) \x01(\t\x12\x1e\n\x16php_metadata_namespace\x18, \x01(\t\x12\x14\n\x0cruby_package\x18- \x01(\t\x12\x43\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOption\":\n\x0cOptimizeMode\x12\t\n\x05SPEED\x10\x01\x12\r\n\tCODE_SIZE\x10\x02\x12\x10\n\x0cLITE_RUNTIME\x10\x03*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02J\x04\x08&\x10\'\"\x84\x02\n\x0eMessageOptions\x12&\n\x17message_set_wire_format\x18\x01 \x01(\x08:\x05\x66\x61lse\x12.\n\x1fno_standard_descriptor_accessor\x18\x02 \x01(\x08:\x05\x66\x61lse\x12\x19\n\ndeprecated\x18\x03 \x01(\x08:\x05\x66\x61lse\x12\x11\n\tmap_entry\x18\x07 \x01(\x08\x12\x43\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOption*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02J\x04\x08\x04\x10\x05J\x04\x08\x05\x10\x06J\x04\x08\x06\x10\x07J\x04\x08\x08\x10\tJ\x04\x08\t\x10\n\"\xbe\x03\n\x0c\x46ieldOptions\x12:\n\x05\x63type\x18\x01 \x01(\x0e\x32#.google.protobuf.FieldOptions.CType:\x06STRING\x12\x0e\n\x06packed\x18\x02 \x01(\x08\x12?\n\x06jstype\x18\x06 \x01(\x0e\x32$.google.protobuf.FieldOptions.JSType:\tJS_NORMAL\x12\x13\n\x04lazy\x18\x05 \x01(\x08:\x05\x66\x61lse\x12\x1e\n\x0funverified_lazy\x18\x0f \x01(\x08:\x05\x66\x61lse\x12\x19\n\ndeprecated\x18\x03 \x01(\x08:\x05\x66\x61lse\x12\x13\n\x04weak\x18\n \x01(\x08:\x05\x66\x61lse\x12\x43\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOption\"/\n\x05\x43Type\x12\n\n\x06STRING\x10\x00\x12\x08\n\x04\x43ORD\x10\x01\x12\x10\n\x0cSTRING_PIECE\x10\x02\"5\n\x06JSType\x12\r\n\tJS_NORMAL\x10\x00\x12\r\n\tJS_STRING\x10\x01\x12\r\n\tJS_NUMBER\x10\x02*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02J\x04\x08\x04\x10\x05\"^\n\x0cOneofOptions\x12\x43\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOption*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\"\x93\x01\n\x0b\x45numOptions\x12\x13\n\x0b\x61llow_alias\x18\x02 \x01(\x08\x12\x19\n\ndeprecated\x18\x03 \x01(\x08:\x05\x66\x61lse\x12\x43\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOption*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02J\x04\x08\x05\x10\x06\"}\n\x10\x45numValueOptions\x12\x19\n\ndeprecated\x18\x01 \x01(\x08:\x05\x66\x61lse\x12\x43\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOption*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\"{\n\x0eServiceOptions\x12\x19\n\ndeprecated\x18! \x01(\x08:\x05\x66\x61lse\x12\x43\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOption*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\"\xad\x02\n\rMethodOptions\x12\x19\n\ndeprecated\x18! \x01(\x08:\x05\x66\x61lse\x12_\n\x11idempotency_level\x18\" \x01(\x0e\x32/.google.protobuf.MethodOptions.IdempotencyLevel:\x13IDEMPOTENCY_UNKNOWN\x12\x43\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOption\"P\n\x10IdempotencyLevel\x12\x17\n\x13IDEMPOTENCY_UNKNOWN\x10\x00\x12\x13\n\x0fNO_SIDE_EFFECTS\x10\x01\x12\x0e\n\nIDEMPOTENT\x10\x02*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\"\x9e\x02\n\x13UninterpretedOption\x12;\n\x04name\x18\x02 \x03(\x0b\x32-.google.protobuf.UninterpretedOption.NamePart\x12\x18\n\x10identifier_value\x18\x03 \x01(\t\x12\x1a\n\x12positive_int_value\x18\x04 \x01(\x04\x12\x1a\n\x12negative_int_value\x18\x05 \x01(\x03\x12\x14\n\x0c\x64ouble_value\x18\x06 \x01(\x01\x12\x14\n\x0cstring_value\x18\x07 \x01(\x0c\x12\x17\n\x0f\x61ggregate_value\x18\x08 \x01(\t\x1a\x33\n\x08NamePart\x12\x11\n\tname_part\x18\x01 \x02(\t\x12\x14\n\x0cis_extension\x18\x02 \x02(\x08\"\xd5\x01\n\x0eSourceCodeInfo\x12:\n\x08location\x18\x01 \x03(\x0b\x32(.google.protobuf.SourceCodeInfo.Location\x1a\x86\x01\n\x08Location\x12\x10\n\x04path\x18\x01 \x03(\x05\x42\x02\x10\x01\x12\x10\n\x04span\x18\x02 \x03(\x05\x42\x02\x10\x01\x12\x18\n\x10leading_comments\x18\x03 \x01(\t\x12\x19\n\x11trailing_comments\x18\x04 \x01(\t\x12!\n\x19leading_detached_comments\x18\x06 \x03(\t\"\xa7\x01\n\x11GeneratedCodeInfo\x12\x41\n\nannotation\x18\x01 \x03(\x0b\x32-.google.protobuf.GeneratedCodeInfo.Annotation\x1aO\n\nAnnotation\x12\x10\n\x04path\x18\x01 \x03(\x05\x42\x02\x10\x01\x12\x13\n\x0bsource_file\x18\x02 \x01(\t\x12\r\n\x05\x62\x65gin\x18\x03 \x01(\x05\x12\x0b\n\x03\x65nd\x18\x04 \x01(\x05\x42~\n\x13\x63om.google.protobufB\x10\x44\x65scriptorProtosH\x01Z-google.golang.org/protobuf/types/descriptorpb\xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1aGoogle.Protobuf.Reflection'
+    )
+else:
+    DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(
+        b'\n google/protobuf/descriptor.proto\x12\x0fgoogle.protobuf\"G\n\x11\x46ileDescriptorSet\x12\x32\n\x04\x66ile\x18\x01 \x03(\x0b\x32$.google.protobuf.FileDescriptorProto\"\xdb\x03\n\x13\x46ileDescriptorProto\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0f\n\x07package\x18\x02 \x01(\t\x12\x12\n\ndependency\x18\x03 \x03(\t\x12\x19\n\x11public_dependency\x18\n \x03(\x05\x12\x17\n\x0fweak_dependency\x18\x0b \x03(\x05\x12\x36\n\x0cmessage_type\x18\x04 \x03(\x0b\x32 .google.protobuf.DescriptorProto\x12\x37\n\tenum_type\x18\x05 \x03(\x0b\x32$.google.protobuf.EnumDescriptorProto\x12\x38\n\x07service\x18\x06 \x03(\x0b\x32\'.google.protobuf.ServiceDescriptorProto\x12\x38\n\textension\x18\x07 \x03(\x0b\x32%.google.protobuf.FieldDescriptorProto\x12-\n\x07options\x18\x08 \x01(\x0b\x32\x1c.google.protobuf.FileOptions\x12\x39\n\x10source_code_info\x18\t \x01(\x0b\x32\x1f.google.protobuf.SourceCodeInfo\x12\x0e\n\x06syntax\x18\x0c \x01(\t\"\xa9\x05\n\x0f\x44\x65scriptorProto\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x34\n\x05\x66ield\x18\x02 \x03(\x0b\x32%.google.protobuf.FieldDescriptorProto\x12\x38\n\textension\x18\x06 \x03(\x0b\x32%.google.protobuf.FieldDescriptorProto\x12\x35\n\x0bnested_type\x18\x03 \x03(\x0b\x32 .google.protobuf.DescriptorProto\x12\x37\n\tenum_type\x18\x04 \x03(\x0b\x32$.google.protobuf.EnumDescriptorProto\x12H\n\x0f\x65xtension_range\x18\x05 \x03(\x0b\x32/.google.protobuf.DescriptorProto.ExtensionRange\x12\x39\n\noneof_decl\x18\x08 \x03(\x0b\x32%.google.protobuf.OneofDescriptorProto\x12\x30\n\x07options\x18\x07 \x01(\x0b\x32\x1f.google.protobuf.MessageOptions\x12\x46\n\x0ereserved_range\x18\t \x03(\x0b\x32..google.protobuf.DescriptorProto.ReservedRange\x12\x15\n\rreserved_name\x18\n \x03(\t\x1a\x65\n\x0e\x45xtensionRange\x12\r\n\x05start\x18\x01 \x01(\x05\x12\x0b\n\x03\x65nd\x18\x02 \x01(\x05\x12\x37\n\x07options\x18\x03 \x01(\x0b\x32&.google.protobuf.ExtensionRangeOptions\x1a+\n\rReservedRange\x12\r\n\x05start\x18\x01 \x01(\x05\x12\x0b\n\x03\x65nd\x18\x02 \x01(\x05\"g\n\x15\x45xtensionRangeOptions\x12\x43\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOption*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\"\xd5\x05\n\x14\x46ieldDescriptorProto\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0e\n\x06number\x18\x03 \x01(\x05\x12:\n\x05label\x18\x04 \x01(\x0e\x32+.google.protobuf.FieldDescriptorProto.Label\x12\x38\n\x04type\x18\x05 \x01(\x0e\x32*.google.protobuf.FieldDescriptorProto.Type\x12\x11\n\ttype_name\x18\x06 \x01(\t\x12\x10\n\x08\x65xtendee\x18\x02 \x01(\t\x12\x15\n\rdefault_value\x18\x07 \x01(\t\x12\x13\n\x0boneof_index\x18\t \x01(\x05\x12\x11\n\tjson_name\x18\n \x01(\t\x12.\n\x07options\x18\x08 \x01(\x0b\x32\x1d.google.protobuf.FieldOptions\x12\x17\n\x0fproto3_optional\x18\x11 \x01(\x08\"\xb6\x02\n\x04Type\x12\x0f\n\x0bTYPE_DOUBLE\x10\x01\x12\x0e\n\nTYPE_FLOAT\x10\x02\x12\x0e\n\nTYPE_INT64\x10\x03\x12\x0f\n\x0bTYPE_UINT64\x10\x04\x12\x0e\n\nTYPE_INT32\x10\x05\x12\x10\n\x0cTYPE_FIXED64\x10\x06\x12\x10\n\x0cTYPE_FIXED32\x10\x07\x12\r\n\tTYPE_BOOL\x10\x08\x12\x0f\n\x0bTYPE_STRING\x10\t\x12\x0e\n\nTYPE_GROUP\x10\n\x12\x10\n\x0cTYPE_MESSAGE\x10\x0b\x12\x0e\n\nTYPE_BYTES\x10\x0c\x12\x0f\n\x0bTYPE_UINT32\x10\r\x12\r\n\tTYPE_ENUM\x10\x0e\x12\x11\n\rTYPE_SFIXED32\x10\x0f\x12\x11\n\rTYPE_SFIXED64\x10\x10\x12\x0f\n\x0bTYPE_SINT32\x10\x11\x12\x0f\n\x0bTYPE_SINT64\x10\x12\"C\n\x05Label\x12\x12\n\x0eLABEL_OPTIONAL\x10\x01\x12\x12\n\x0eLABEL_REQUIRED\x10\x02\x12\x12\n\x0eLABEL_REPEATED\x10\x03\"T\n\x14OneofDescriptorProto\x12\x0c\n\x04name\x18\x01 \x01(\t\x12.\n\x07options\x18\x02 \x01(\x0b\x32\x1d.google.protobuf.OneofOptions\"\xa4\x02\n\x13\x45numDescriptorProto\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x38\n\x05value\x18\x02 \x03(\x0b\x32).google.protobuf.EnumValueDescriptorProto\x12-\n\x07options\x18\x03 \x01(\x0b\x32\x1c.google.protobuf.EnumOptions\x12N\n\x0ereserved_range\x18\x04 \x03(\x0b\x32\x36.google.protobuf.EnumDescriptorProto.EnumReservedRange\x12\x15\n\rreserved_name\x18\x05 \x03(\t\x1a/\n\x11\x45numReservedRange\x12\r\n\x05start\x18\x01 \x01(\x05\x12\x0b\n\x03\x65nd\x18\x02 \x01(\x05\"l\n\x18\x45numValueDescriptorProto\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0e\n\x06number\x18\x02 \x01(\x05\x12\x32\n\x07options\x18\x03 \x01(\x0b\x32!.google.protobuf.EnumValueOptions\"\x90\x01\n\x16ServiceDescriptorProto\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x36\n\x06method\x18\x02 \x03(\x0b\x32&.google.protobuf.MethodDescriptorProto\x12\x30\n\x07options\x18\x03 \x01(\x0b\x32\x1f.google.protobuf.ServiceOptions\"\xc1\x01\n\x15MethodDescriptorProto\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x12\n\ninput_type\x18\x02 \x01(\t\x12\x13\n\x0boutput_type\x18\x03 \x01(\t\x12/\n\x07options\x18\x04 \x01(\x0b\x32\x1e.google.protobuf.MethodOptions\x12\x1f\n\x10\x63lient_streaming\x18\x05 \x01(\x08:\x05\x66\x61lse\x12\x1f\n\x10server_streaming\x18\x06 \x01(\x08:\x05\x66\x61lse\"\xa5\x06\n\x0b\x46ileOptions\x12\x14\n\x0cjava_package\x18\x01 \x01(\t\x12\x1c\n\x14java_outer_classname\x18\x08 \x01(\t\x12\"\n\x13java_multiple_files\x18\n \x01(\x08:\x05\x66\x61lse\x12)\n\x1djava_generate_equals_and_hash\x18\x14 \x01(\x08\x42\x02\x18\x01\x12%\n\x16java_string_check_utf8\x18\x1b \x01(\x08:\x05\x66\x61lse\x12\x46\n\x0coptimize_for\x18\t \x01(\x0e\x32).google.protobuf.FileOptions.OptimizeMode:\x05SPEED\x12\x12\n\ngo_package\x18\x0b \x01(\t\x12\"\n\x13\x63\x63_generic_services\x18\x10 \x01(\x08:\x05\x66\x61lse\x12$\n\x15java_generic_services\x18\x11 \x01(\x08:\x05\x66\x61lse\x12\"\n\x13py_generic_services\x18\x12 \x01(\x08:\x05\x66\x61lse\x12#\n\x14php_generic_services\x18* \x01(\x08:\x05\x66\x61lse\x12\x19\n\ndeprecated\x18\x17 \x01(\x08:\x05\x66\x61lse\x12\x1e\n\x10\x63\x63_enable_arenas\x18\x1f \x01(\x08:\x04true\x12\x19\n\x11objc_class_prefix\x18$ \x01(\t\x12\x18\n\x10\x63sharp_namespace\x18% \x01(\t\x12\x14\n\x0cswift_prefix\x18\' \x01(\t\x12\x18\n\x10php_class_prefix\x18( \x01(\t\x12\x15\n\rphp_namespace\x18) \x01(\t\x12\x1e\n\x16php_metadata_namespace\x18, \x01(\t\x12\x14\n\x0cruby_package\x18- \x01(\t\x12\x43\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOption\":\n\x0cOptimizeMode\x12\t\n\x05SPEED\x10\x01\x12\r\n\tCODE_SIZE\x10\x02\x12\x10\n\x0cLITE_RUNTIME\x10\x03*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02J\x04\x08&\x10\'\"\x84\x02\n\x0eMessageOptions\x12&\n\x17message_set_wire_format\x18\x01 \x01(\x08:\x05\x66\x61lse\x12.\n\x1fno_standard_descriptor_accessor\x18\x02 \x01(\x08:\x05\x66\x61lse\x12\x19\n\ndeprecated\x18\x03 \x01(\x08:\x05\x66\x61lse\x12\x11\n\tmap_entry\x18\x07 \x01(\x08\x12\x43\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOption*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02J\x04\x08\x04\x10\x05J\x04\x08\x05\x10\x06J\x04\x08\x06\x10\x07J\x04\x08\x08\x10\tJ\x04\x08\t\x10\n\"\xbe\x03\n\x0c\x46ieldOptions\x12:\n\x05\x63type\x18\x01 \x01(\x0e\x32#.google.protobuf.FieldOptions.CType:\x06STRING\x12\x0e\n\x06packed\x18\x02 \x01(\x08\x12?\n\x06jstype\x18\x06 \x01(\x0e\x32$.google.protobuf.FieldOptions.JSType:\tJS_NORMAL\x12\x13\n\x04lazy\x18\x05 \x01(\x08:\x05\x66\x61lse\x12\x1e\n\x0funverified_lazy\x18\x0f \x01(\x08:\x05\x66\x61lse\x12\x19\n\ndeprecated\x18\x03 \x01(\x08:\x05\x66\x61lse\x12\x13\n\x04weak\x18\n \x01(\x08:\x05\x66\x61lse\x12\x43\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOption\"/\n\x05\x43Type\x12\n\n\x06STRING\x10\x00\x12\x08\n\x04\x43ORD\x10\x01\x12\x10\n\x0cSTRING_PIECE\x10\x02\"5\n\x06JSType\x12\r\n\tJS_NORMAL\x10\x00\x12\r\n\tJS_STRING\x10\x01\x12\r\n\tJS_NUMBER\x10\x02*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02J\x04\x08\x04\x10\x05\"^\n\x0cOneofOptions\x12\x43\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOption*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\"\x93\x01\n\x0b\x45numOptions\x12\x13\n\x0b\x61llow_alias\x18\x02 \x01(\x08\x12\x19\n\ndeprecated\x18\x03 \x01(\x08:\x05\x66\x61lse\x12\x43\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOption*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02J\x04\x08\x05\x10\x06\"}\n\x10\x45numValueOptions\x12\x19\n\ndeprecated\x18\x01 \x01(\x08:\x05\x66\x61lse\x12\x43\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOption*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\"{\n\x0eServiceOptions\x12\x19\n\ndeprecated\x18! \x01(\x08:\x05\x66\x61lse\x12\x43\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOption*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\"\xad\x02\n\rMethodOptions\x12\x19\n\ndeprecated\x18! \x01(\x08:\x05\x66\x61lse\x12_\n\x11idempotency_level\x18\" \x01(\x0e\x32/.google.protobuf.MethodOptions.IdempotencyLevel:\x13IDEMPOTENCY_UNKNOWN\x12\x43\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOption\"P\n\x10IdempotencyLevel\x12\x17\n\x13IDEMPOTENCY_UNKNOWN\x10\x00\x12\x13\n\x0fNO_SIDE_EFFECTS\x10\x01\x12\x0e\n\nIDEMPOTENT\x10\x02*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\"\x9e\x02\n\x13UninterpretedOption\x12;\n\x04name\x18\x02 \x03(\x0b\x32-.google.protobuf.UninterpretedOption.NamePart\x12\x18\n\x10identifier_value\x18\x03 \x01(\t\x12\x1a\n\x12positive_int_value\x18\x04 \x01(\x04\x12\x1a\n\x12negative_int_value\x18\x05 \x01(\x03\x12\x14\n\x0c\x64ouble_value\x18\x06 \x01(\x01\x12\x14\n\x0cstring_value\x18\x07 \x01(\x0c\x12\x17\n\x0f\x61ggregate_value\x18\x08 \x01(\t\x1a\x33\n\x08NamePart\x12\x11\n\tname_part\x18\x01 \x02(\t\x12\x14\n\x0cis_extension\x18\x02 \x02(\x08\"\xd5\x01\n\x0eSourceCodeInfo\x12:\n\x08location\x18\x01 \x03(\x0b\x32(.google.protobuf.SourceCodeInfo.Location\x1a\x86\x01\n\x08Location\x12\x10\n\x04path\x18\x01 \x03(\x05\x42\x02\x10\x01\x12\x10\n\x04span\x18\x02 \x03(\x05\x42\x02\x10\x01\x12\x18\n\x10leading_comments\x18\x03 \x01(\t\x12\x19\n\x11trailing_comments\x18\x04 \x01(\t\x12!\n\x19leading_detached_comments\x18\x06 \x03(\t\"\xa7\x01\n\x11GeneratedCodeInfo\x12\x41\n\nannotation\x18\x01 \x03(\x0b\x32-.google.protobuf.GeneratedCodeInfo.Annotation\x1aO\n\nAnnotation\x12\x10\n\x04path\x18\x01 \x03(\x05\x42\x02\x10\x01\x12\x13\n\x0bsource_file\x18\x02 \x01(\t\x12\r\n\x05\x62\x65gin\x18\x03 \x01(\x05\x12\x0b\n\x03\x65nd\x18\x04 \x01(\x05\x42~\n\x13\x63om.google.protobufB\x10\x44\x65scriptorProtosH\x01Z-google.golang.org/protobuf/types/descriptorpb\xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1aGoogle.Protobuf.Reflection')
+
+if _descriptor._USE_C_DESCRIPTORS == False:
+    _FIELDDESCRIPTORPROTO_TYPE = _descriptor.EnumDescriptor(
+        name='Type',
+        full_name='google.protobuf.FieldDescriptorProto.Type',
+        filename=None,
+        file=DESCRIPTOR,
+        create_key=_descriptor._internal_create_key,
+        values=[
+            _descriptor.EnumValueDescriptor(
+                name='TYPE_DOUBLE', index=0, number=1,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+            _descriptor.EnumValueDescriptor(
+                name='TYPE_FLOAT', index=1, number=2,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+            _descriptor.EnumValueDescriptor(
+                name='TYPE_INT64', index=2, number=3,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+            _descriptor.EnumValueDescriptor(
+                name='TYPE_UINT64', index=3, number=4,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+            _descriptor.EnumValueDescriptor(
+                name='TYPE_INT32', index=4, number=5,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+            _descriptor.EnumValueDescriptor(
+                name='TYPE_FIXED64', index=5, number=6,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+            _descriptor.EnumValueDescriptor(
+                name='TYPE_FIXED32', index=6, number=7,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+            _descriptor.EnumValueDescriptor(
+                name='TYPE_BOOL', index=7, number=8,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+            _descriptor.EnumValueDescriptor(
+                name='TYPE_STRING', index=8, number=9,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+            _descriptor.EnumValueDescriptor(
+                name='TYPE_GROUP', index=9, number=10,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+            _descriptor.EnumValueDescriptor(
+                name='TYPE_MESSAGE', index=10, number=11,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+            _descriptor.EnumValueDescriptor(
+                name='TYPE_BYTES', index=11, number=12,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+            _descriptor.EnumValueDescriptor(
+                name='TYPE_UINT32', index=12, number=13,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+            _descriptor.EnumValueDescriptor(
+                name='TYPE_ENUM', index=13, number=14,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+            _descriptor.EnumValueDescriptor(
+                name='TYPE_SFIXED32', index=14, number=15,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+            _descriptor.EnumValueDescriptor(
+                name='TYPE_SFIXED64', index=15, number=16,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+            _descriptor.EnumValueDescriptor(
+                name='TYPE_SINT32', index=16, number=17,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+            _descriptor.EnumValueDescriptor(
+                name='TYPE_SINT64', index=17, number=18,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+        ],
+        containing_type=None,
+        serialized_options=None,
+    )
+    _sym_db.RegisterEnumDescriptor(_FIELDDESCRIPTORPROTO_TYPE)
+
+    _FIELDDESCRIPTORPROTO_LABEL = _descriptor.EnumDescriptor(
+        name='Label',
+        full_name='google.protobuf.FieldDescriptorProto.Label',
+        filename=None,
+        file=DESCRIPTOR,
+        create_key=_descriptor._internal_create_key,
+        values=[
+            _descriptor.EnumValueDescriptor(
+                name='LABEL_OPTIONAL', index=0, number=1,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+            _descriptor.EnumValueDescriptor(
+                name='LABEL_REQUIRED', index=1, number=2,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+            _descriptor.EnumValueDescriptor(
+                name='LABEL_REPEATED', index=2, number=3,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+        ],
+        containing_type=None,
+        serialized_options=None,
+    )
+    _sym_db.RegisterEnumDescriptor(_FIELDDESCRIPTORPROTO_LABEL)
+
+    _FILEOPTIONS_OPTIMIZEMODE = _descriptor.EnumDescriptor(
+        name='OptimizeMode',
+        full_name='google.protobuf.FileOptions.OptimizeMode',
+        filename=None,
+        file=DESCRIPTOR,
+        create_key=_descriptor._internal_create_key,
+        values=[
+            _descriptor.EnumValueDescriptor(
+                name='SPEED', index=0, number=1,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+            _descriptor.EnumValueDescriptor(
+                name='CODE_SIZE', index=1, number=2,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+            _descriptor.EnumValueDescriptor(
+                name='LITE_RUNTIME', index=2, number=3,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+        ],
+        containing_type=None,
+        serialized_options=None,
+    )
+    _sym_db.RegisterEnumDescriptor(_FILEOPTIONS_OPTIMIZEMODE)
+
+    _FIELDOPTIONS_CTYPE = _descriptor.EnumDescriptor(
+        name='CType',
+        full_name='google.protobuf.FieldOptions.CType',
+        filename=None,
+        file=DESCRIPTOR,
+        create_key=_descriptor._internal_create_key,
+        values=[
+            _descriptor.EnumValueDescriptor(
+                name='STRING', index=0, number=0,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+            _descriptor.EnumValueDescriptor(
+                name='CORD', index=1, number=1,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+            _descriptor.EnumValueDescriptor(
+                name='STRING_PIECE', index=2, number=2,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+        ],
+        containing_type=None,
+        serialized_options=None,
+    )
+    _sym_db.RegisterEnumDescriptor(_FIELDOPTIONS_CTYPE)
+
+    _FIELDOPTIONS_JSTYPE = _descriptor.EnumDescriptor(
+        name='JSType',
+        full_name='google.protobuf.FieldOptions.JSType',
+        filename=None,
+        file=DESCRIPTOR,
+        create_key=_descriptor._internal_create_key,
+        values=[
+            _descriptor.EnumValueDescriptor(
+                name='JS_NORMAL', index=0, number=0,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+            _descriptor.EnumValueDescriptor(
+                name='JS_STRING', index=1, number=1,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+            _descriptor.EnumValueDescriptor(
+                name='JS_NUMBER', index=2, number=2,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+        ],
+        containing_type=None,
+        serialized_options=None,
+    )
+    _sym_db.RegisterEnumDescriptor(_FIELDOPTIONS_JSTYPE)
+
+    _METHODOPTIONS_IDEMPOTENCYLEVEL = _descriptor.EnumDescriptor(
+        name='IdempotencyLevel',
+        full_name='google.protobuf.MethodOptions.IdempotencyLevel',
+        filename=None,
+        file=DESCRIPTOR,
+        create_key=_descriptor._internal_create_key,
+        values=[
+            _descriptor.EnumValueDescriptor(
+                name='IDEMPOTENCY_UNKNOWN', index=0, number=0,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+            _descriptor.EnumValueDescriptor(
+                name='NO_SIDE_EFFECTS', index=1, number=1,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+            _descriptor.EnumValueDescriptor(
+                name='IDEMPOTENT', index=2, number=2,
+                serialized_options=None,
+                type=None,
+                create_key=_descriptor._internal_create_key),
+        ],
+        containing_type=None,
+        serialized_options=None,
+    )
+    _sym_db.RegisterEnumDescriptor(_METHODOPTIONS_IDEMPOTENCYLEVEL)
+
+    _FILEDESCRIPTORSET = _descriptor.Descriptor(
+        name='FileDescriptorSet',
+        full_name='google.protobuf.FileDescriptorSet',
+        filename=None,
+        file=DESCRIPTOR,
+        containing_type=None,
+        create_key=_descriptor._internal_create_key,
+        fields=[
+            _descriptor.FieldDescriptor(
+                name='file', full_name='google.protobuf.FileDescriptorSet.file', index=0,
+                number=1, type=11, cpp_type=10, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        ],
+        extensions=[
+        ],
+        nested_types=[],
+        enum_types=[
+        ],
+        serialized_options=None,
+        is_extendable=False,
+        syntax='proto2',
+        extension_ranges=[],
+        oneofs=[
+        ],
+    )
+
+    _FILEDESCRIPTORPROTO = _descriptor.Descriptor(
+        name='FileDescriptorProto',
+        full_name='google.protobuf.FileDescriptorProto',
+        filename=None,
+        file=DESCRIPTOR,
+        containing_type=None,
+        create_key=_descriptor._internal_create_key,
+        fields=[
+            _descriptor.FieldDescriptor(
+                name='name', full_name='google.protobuf.FileDescriptorProto.name', index=0,
+                number=1, type=9, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='package', full_name='google.protobuf.FileDescriptorProto.package', index=1,
+                number=2, type=9, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='dependency', full_name='google.protobuf.FileDescriptorProto.dependency', index=2,
+                number=3, type=9, cpp_type=9, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='public_dependency', full_name='google.protobuf.FileDescriptorProto.public_dependency', index=3,
+                number=10, type=5, cpp_type=1, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='weak_dependency', full_name='google.protobuf.FileDescriptorProto.weak_dependency', index=4,
+                number=11, type=5, cpp_type=1, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='message_type', full_name='google.protobuf.FileDescriptorProto.message_type', index=5,
+                number=4, type=11, cpp_type=10, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='enum_type', full_name='google.protobuf.FileDescriptorProto.enum_type', index=6,
+                number=5, type=11, cpp_type=10, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='service', full_name='google.protobuf.FileDescriptorProto.service', index=7,
+                number=6, type=11, cpp_type=10, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='extension', full_name='google.protobuf.FileDescriptorProto.extension', index=8,
+                number=7, type=11, cpp_type=10, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='options', full_name='google.protobuf.FileDescriptorProto.options', index=9,
+                number=8, type=11, cpp_type=10, label=1,
+                has_default_value=False, default_value=None,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='source_code_info', full_name='google.protobuf.FileDescriptorProto.source_code_info', index=10,
+                number=9, type=11, cpp_type=10, label=1,
+                has_default_value=False, default_value=None,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='syntax', full_name='google.protobuf.FileDescriptorProto.syntax', index=11,
+                number=12, type=9, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        ],
+        extensions=[
+        ],
+        nested_types=[],
+        enum_types=[
+        ],
+        serialized_options=None,
+        is_extendable=False,
+        syntax='proto2',
+        extension_ranges=[],
+        oneofs=[
+        ],
+    )
+
+    _DESCRIPTORPROTO_EXTENSIONRANGE = _descriptor.Descriptor(
+        name='ExtensionRange',
+        full_name='google.protobuf.DescriptorProto.ExtensionRange',
+        filename=None,
+        file=DESCRIPTOR,
+        containing_type=None,
+        create_key=_descriptor._internal_create_key,
+        fields=[
+            _descriptor.FieldDescriptor(
+                name='start', full_name='google.protobuf.DescriptorProto.ExtensionRange.start', index=0,
+                number=1, type=5, cpp_type=1, label=1,
+                has_default_value=False, default_value=0,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='end', full_name='google.protobuf.DescriptorProto.ExtensionRange.end', index=1,
+                number=2, type=5, cpp_type=1, label=1,
+                has_default_value=False, default_value=0,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='options', full_name='google.protobuf.DescriptorProto.ExtensionRange.options', index=2,
+                number=3, type=11, cpp_type=10, label=1,
+                has_default_value=False, default_value=None,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        ],
+        extensions=[
+        ],
+        nested_types=[],
+        enum_types=[
+        ],
+        serialized_options=None,
+        is_extendable=False,
+        syntax='proto2',
+        extension_ranges=[],
+        oneofs=[
+        ],
+    )
+
+    _DESCRIPTORPROTO_RESERVEDRANGE = _descriptor.Descriptor(
+        name='ReservedRange',
+        full_name='google.protobuf.DescriptorProto.ReservedRange',
+        filename=None,
+        file=DESCRIPTOR,
+        containing_type=None,
+        create_key=_descriptor._internal_create_key,
+        fields=[
+            _descriptor.FieldDescriptor(
+                name='start', full_name='google.protobuf.DescriptorProto.ReservedRange.start', index=0,
+                number=1, type=5, cpp_type=1, label=1,
+                has_default_value=False, default_value=0,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='end', full_name='google.protobuf.DescriptorProto.ReservedRange.end', index=1,
+                number=2, type=5, cpp_type=1, label=1,
+                has_default_value=False, default_value=0,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        ],
+        extensions=[
+        ],
+        nested_types=[],
+        enum_types=[
+        ],
+        serialized_options=None,
+        is_extendable=False,
+        syntax='proto2',
+        extension_ranges=[],
+        oneofs=[
+        ],
+    )
+
+    _DESCRIPTORPROTO = _descriptor.Descriptor(
+        name='DescriptorProto',
+        full_name='google.protobuf.DescriptorProto',
+        filename=None,
+        file=DESCRIPTOR,
+        containing_type=None,
+        create_key=_descriptor._internal_create_key,
+        fields=[
+            _descriptor.FieldDescriptor(
+                name='name', full_name='google.protobuf.DescriptorProto.name', index=0,
+                number=1, type=9, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='field', full_name='google.protobuf.DescriptorProto.field', index=1,
+                number=2, type=11, cpp_type=10, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='extension', full_name='google.protobuf.DescriptorProto.extension', index=2,
+                number=6, type=11, cpp_type=10, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='nested_type', full_name='google.protobuf.DescriptorProto.nested_type', index=3,
+                number=3, type=11, cpp_type=10, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='enum_type', full_name='google.protobuf.DescriptorProto.enum_type', index=4,
+                number=4, type=11, cpp_type=10, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='extension_range', full_name='google.protobuf.DescriptorProto.extension_range', index=5,
+                number=5, type=11, cpp_type=10, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='oneof_decl', full_name='google.protobuf.DescriptorProto.oneof_decl', index=6,
+                number=8, type=11, cpp_type=10, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='options', full_name='google.protobuf.DescriptorProto.options', index=7,
+                number=7, type=11, cpp_type=10, label=1,
+                has_default_value=False, default_value=None,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='reserved_range', full_name='google.protobuf.DescriptorProto.reserved_range', index=8,
+                number=9, type=11, cpp_type=10, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='reserved_name', full_name='google.protobuf.DescriptorProto.reserved_name', index=9,
+                number=10, type=9, cpp_type=9, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        ],
+        extensions=[
+        ],
+        nested_types=[_DESCRIPTORPROTO_EXTENSIONRANGE, _DESCRIPTORPROTO_RESERVEDRANGE, ],
+        enum_types=[
+        ],
+        serialized_options=None,
+        is_extendable=False,
+        syntax='proto2',
+        extension_ranges=[],
+        oneofs=[
+        ],
+    )
+
+    _EXTENSIONRANGEOPTIONS = _descriptor.Descriptor(
+        name='ExtensionRangeOptions',
+        full_name='google.protobuf.ExtensionRangeOptions',
+        filename=None,
+        file=DESCRIPTOR,
+        containing_type=None,
+        create_key=_descriptor._internal_create_key,
+        fields=[
+            _descriptor.FieldDescriptor(
+                name='uninterpreted_option', full_name='google.protobuf.ExtensionRangeOptions.uninterpreted_option',
+                index=0,
+                number=999, type=11, cpp_type=10, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        ],
+        extensions=[
+        ],
+        nested_types=[],
+        enum_types=[
+        ],
+        serialized_options=None,
+        is_extendable=True,
+        syntax='proto2',
+        extension_ranges=[(1000, 536870912), ],
+        oneofs=[
+        ],
+    )
+
+    _FIELDDESCRIPTORPROTO = _descriptor.Descriptor(
+        name='FieldDescriptorProto',
+        full_name='google.protobuf.FieldDescriptorProto',
+        filename=None,
+        file=DESCRIPTOR,
+        containing_type=None,
+        create_key=_descriptor._internal_create_key,
+        fields=[
+            _descriptor.FieldDescriptor(
+                name='name', full_name='google.protobuf.FieldDescriptorProto.name', index=0,
+                number=1, type=9, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='number', full_name='google.protobuf.FieldDescriptorProto.number', index=1,
+                number=3, type=5, cpp_type=1, label=1,
+                has_default_value=False, default_value=0,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='label', full_name='google.protobuf.FieldDescriptorProto.label', index=2,
+                number=4, type=14, cpp_type=8, label=1,
+                has_default_value=False, default_value=1,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='type', full_name='google.protobuf.FieldDescriptorProto.type', index=3,
+                number=5, type=14, cpp_type=8, label=1,
+                has_default_value=False, default_value=1,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='type_name', full_name='google.protobuf.FieldDescriptorProto.type_name', index=4,
+                number=6, type=9, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='extendee', full_name='google.protobuf.FieldDescriptorProto.extendee', index=5,
+                number=2, type=9, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='default_value', full_name='google.protobuf.FieldDescriptorProto.default_value', index=6,
+                number=7, type=9, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='oneof_index', full_name='google.protobuf.FieldDescriptorProto.oneof_index', index=7,
+                number=9, type=5, cpp_type=1, label=1,
+                has_default_value=False, default_value=0,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='json_name', full_name='google.protobuf.FieldDescriptorProto.json_name', index=8,
+                number=10, type=9, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='options', full_name='google.protobuf.FieldDescriptorProto.options', index=9,
+                number=8, type=11, cpp_type=10, label=1,
+                has_default_value=False, default_value=None,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='proto3_optional', full_name='google.protobuf.FieldDescriptorProto.proto3_optional', index=10,
+                number=17, type=8, cpp_type=7, label=1,
+                has_default_value=False, default_value=False,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        ],
+        extensions=[
+        ],
+        nested_types=[],
+        enum_types=[
+            _FIELDDESCRIPTORPROTO_TYPE,
+            _FIELDDESCRIPTORPROTO_LABEL,
+        ],
+        serialized_options=None,
+        is_extendable=False,
+        syntax='proto2',
+        extension_ranges=[],
+        oneofs=[
+        ],
+    )
+
+    _ONEOFDESCRIPTORPROTO = _descriptor.Descriptor(
+        name='OneofDescriptorProto',
+        full_name='google.protobuf.OneofDescriptorProto',
+        filename=None,
+        file=DESCRIPTOR,
+        containing_type=None,
+        create_key=_descriptor._internal_create_key,
+        fields=[
+            _descriptor.FieldDescriptor(
+                name='name', full_name='google.protobuf.OneofDescriptorProto.name', index=0,
+                number=1, type=9, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='options', full_name='google.protobuf.OneofDescriptorProto.options', index=1,
+                number=2, type=11, cpp_type=10, label=1,
+                has_default_value=False, default_value=None,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        ],
+        extensions=[
+        ],
+        nested_types=[],
+        enum_types=[
+        ],
+        serialized_options=None,
+        is_extendable=False,
+        syntax='proto2',
+        extension_ranges=[],
+        oneofs=[
+        ],
+    )
+
+    _ENUMDESCRIPTORPROTO_ENUMRESERVEDRANGE = _descriptor.Descriptor(
+        name='EnumReservedRange',
+        full_name='google.protobuf.EnumDescriptorProto.EnumReservedRange',
+        filename=None,
+        file=DESCRIPTOR,
+        containing_type=None,
+        create_key=_descriptor._internal_create_key,
+        fields=[
+            _descriptor.FieldDescriptor(
+                name='start', full_name='google.protobuf.EnumDescriptorProto.EnumReservedRange.start', index=0,
+                number=1, type=5, cpp_type=1, label=1,
+                has_default_value=False, default_value=0,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='end', full_name='google.protobuf.EnumDescriptorProto.EnumReservedRange.end', index=1,
+                number=2, type=5, cpp_type=1, label=1,
+                has_default_value=False, default_value=0,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        ],
+        extensions=[
+        ],
+        nested_types=[],
+        enum_types=[
+        ],
+        serialized_options=None,
+        is_extendable=False,
+        syntax='proto2',
+        extension_ranges=[],
+        oneofs=[
+        ],
+    )
+
+    _ENUMDESCRIPTORPROTO = _descriptor.Descriptor(
+        name='EnumDescriptorProto',
+        full_name='google.protobuf.EnumDescriptorProto',
+        filename=None,
+        file=DESCRIPTOR,
+        containing_type=None,
+        create_key=_descriptor._internal_create_key,
+        fields=[
+            _descriptor.FieldDescriptor(
+                name='name', full_name='google.protobuf.EnumDescriptorProto.name', index=0,
+                number=1, type=9, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='value', full_name='google.protobuf.EnumDescriptorProto.value', index=1,
+                number=2, type=11, cpp_type=10, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='options', full_name='google.protobuf.EnumDescriptorProto.options', index=2,
+                number=3, type=11, cpp_type=10, label=1,
+                has_default_value=False, default_value=None,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='reserved_range', full_name='google.protobuf.EnumDescriptorProto.reserved_range', index=3,
+                number=4, type=11, cpp_type=10, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='reserved_name', full_name='google.protobuf.EnumDescriptorProto.reserved_name', index=4,
+                number=5, type=9, cpp_type=9, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        ],
+        extensions=[
+        ],
+        nested_types=[_ENUMDESCRIPTORPROTO_ENUMRESERVEDRANGE, ],
+        enum_types=[
+        ],
+        serialized_options=None,
+        is_extendable=False,
+        syntax='proto2',
+        extension_ranges=[],
+        oneofs=[
+        ],
+    )
+
+    _ENUMVALUEDESCRIPTORPROTO = _descriptor.Descriptor(
+        name='EnumValueDescriptorProto',
+        full_name='google.protobuf.EnumValueDescriptorProto',
+        filename=None,
+        file=DESCRIPTOR,
+        containing_type=None,
+        create_key=_descriptor._internal_create_key,
+        fields=[
+            _descriptor.FieldDescriptor(
+                name='name', full_name='google.protobuf.EnumValueDescriptorProto.name', index=0,
+                number=1, type=9, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='number', full_name='google.protobuf.EnumValueDescriptorProto.number', index=1,
+                number=2, type=5, cpp_type=1, label=1,
+                has_default_value=False, default_value=0,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='options', full_name='google.protobuf.EnumValueDescriptorProto.options', index=2,
+                number=3, type=11, cpp_type=10, label=1,
+                has_default_value=False, default_value=None,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        ],
+        extensions=[
+        ],
+        nested_types=[],
+        enum_types=[
+        ],
+        serialized_options=None,
+        is_extendable=False,
+        syntax='proto2',
+        extension_ranges=[],
+        oneofs=[
+        ],
+    )
+
+    _SERVICEDESCRIPTORPROTO = _descriptor.Descriptor(
+        name='ServiceDescriptorProto',
+        full_name='google.protobuf.ServiceDescriptorProto',
+        filename=None,
+        file=DESCRIPTOR,
+        containing_type=None,
+        create_key=_descriptor._internal_create_key,
+        fields=[
+            _descriptor.FieldDescriptor(
+                name='name', full_name='google.protobuf.ServiceDescriptorProto.name', index=0,
+                number=1, type=9, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='method', full_name='google.protobuf.ServiceDescriptorProto.method', index=1,
+                number=2, type=11, cpp_type=10, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='options', full_name='google.protobuf.ServiceDescriptorProto.options', index=2,
+                number=3, type=11, cpp_type=10, label=1,
+                has_default_value=False, default_value=None,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        ],
+        extensions=[
+        ],
+        nested_types=[],
+        enum_types=[
+        ],
+        serialized_options=None,
+        is_extendable=False,
+        syntax='proto2',
+        extension_ranges=[],
+        oneofs=[
+        ],
+    )
+
+    _METHODDESCRIPTORPROTO = _descriptor.Descriptor(
+        name='MethodDescriptorProto',
+        full_name='google.protobuf.MethodDescriptorProto',
+        filename=None,
+        file=DESCRIPTOR,
+        containing_type=None,
+        create_key=_descriptor._internal_create_key,
+        fields=[
+            _descriptor.FieldDescriptor(
+                name='name', full_name='google.protobuf.MethodDescriptorProto.name', index=0,
+                number=1, type=9, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='input_type', full_name='google.protobuf.MethodDescriptorProto.input_type', index=1,
+                number=2, type=9, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='output_type', full_name='google.protobuf.MethodDescriptorProto.output_type', index=2,
+                number=3, type=9, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='options', full_name='google.protobuf.MethodDescriptorProto.options', index=3,
+                number=4, type=11, cpp_type=10, label=1,
+                has_default_value=False, default_value=None,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='client_streaming', full_name='google.protobuf.MethodDescriptorProto.client_streaming', index=4,
+                number=5, type=8, cpp_type=7, label=1,
+                has_default_value=True, default_value=False,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='server_streaming', full_name='google.protobuf.MethodDescriptorProto.server_streaming', index=5,
+                number=6, type=8, cpp_type=7, label=1,
+                has_default_value=True, default_value=False,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        ],
+        extensions=[
+        ],
+        nested_types=[],
+        enum_types=[
+        ],
+        serialized_options=None,
+        is_extendable=False,
+        syntax='proto2',
+        extension_ranges=[],
+        oneofs=[
+        ],
+    )
+
+    _FILEOPTIONS = _descriptor.Descriptor(
+        name='FileOptions',
+        full_name='google.protobuf.FileOptions',
+        filename=None,
+        file=DESCRIPTOR,
+        containing_type=None,
+        create_key=_descriptor._internal_create_key,
+        fields=[
+            _descriptor.FieldDescriptor(
+                name='java_package', full_name='google.protobuf.FileOptions.java_package', index=0,
+                number=1, type=9, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='java_outer_classname', full_name='google.protobuf.FileOptions.java_outer_classname', index=1,
+                number=8, type=9, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='java_multiple_files', full_name='google.protobuf.FileOptions.java_multiple_files', index=2,
+                number=10, type=8, cpp_type=7, label=1,
+                has_default_value=True, default_value=False,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='java_generate_equals_and_hash',
+                full_name='google.protobuf.FileOptions.java_generate_equals_and_hash', index=3,
+                number=20, type=8, cpp_type=7, label=1,
+                has_default_value=False, default_value=False,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='java_string_check_utf8', full_name='google.protobuf.FileOptions.java_string_check_utf8', index=4,
+                number=27, type=8, cpp_type=7, label=1,
+                has_default_value=True, default_value=False,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='optimize_for', full_name='google.protobuf.FileOptions.optimize_for', index=5,
+                number=9, type=14, cpp_type=8, label=1,
+                has_default_value=True, default_value=1,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='go_package', full_name='google.protobuf.FileOptions.go_package', index=6,
+                number=11, type=9, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='cc_generic_services', full_name='google.protobuf.FileOptions.cc_generic_services', index=7,
+                number=16, type=8, cpp_type=7, label=1,
+                has_default_value=True, default_value=False,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='java_generic_services', full_name='google.protobuf.FileOptions.java_generic_services', index=8,
+                number=17, type=8, cpp_type=7, label=1,
+                has_default_value=True, default_value=False,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='py_generic_services', full_name='google.protobuf.FileOptions.py_generic_services', index=9,
+                number=18, type=8, cpp_type=7, label=1,
+                has_default_value=True, default_value=False,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='php_generic_services', full_name='google.protobuf.FileOptions.php_generic_services', index=10,
+                number=42, type=8, cpp_type=7, label=1,
+                has_default_value=True, default_value=False,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='deprecated', full_name='google.protobuf.FileOptions.deprecated', index=11,
+                number=23, type=8, cpp_type=7, label=1,
+                has_default_value=True, default_value=False,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='cc_enable_arenas', full_name='google.protobuf.FileOptions.cc_enable_arenas', index=12,
+                number=31, type=8, cpp_type=7, label=1,
+                has_default_value=True, default_value=True,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='objc_class_prefix', full_name='google.protobuf.FileOptions.objc_class_prefix', index=13,
+                number=36, type=9, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='csharp_namespace', full_name='google.protobuf.FileOptions.csharp_namespace', index=14,
+                number=37, type=9, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='swift_prefix', full_name='google.protobuf.FileOptions.swift_prefix', index=15,
+                number=39, type=9, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='php_class_prefix', full_name='google.protobuf.FileOptions.php_class_prefix', index=16,
+                number=40, type=9, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='php_namespace', full_name='google.protobuf.FileOptions.php_namespace', index=17,
+                number=41, type=9, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='php_metadata_namespace', full_name='google.protobuf.FileOptions.php_metadata_namespace', index=18,
+                number=44, type=9, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='ruby_package', full_name='google.protobuf.FileOptions.ruby_package', index=19,
+                number=45, type=9, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='uninterpreted_option', full_name='google.protobuf.FileOptions.uninterpreted_option', index=20,
+                number=999, type=11, cpp_type=10, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        ],
+        extensions=[
+        ],
+        nested_types=[],
+        enum_types=[
+            _FILEOPTIONS_OPTIMIZEMODE,
+        ],
+        serialized_options=None,
+        is_extendable=True,
+        syntax='proto2',
+        extension_ranges=[(1000, 536870912), ],
+        oneofs=[
+        ],
+    )
+
+    _MESSAGEOPTIONS = _descriptor.Descriptor(
+        name='MessageOptions',
+        full_name='google.protobuf.MessageOptions',
+        filename=None,
+        file=DESCRIPTOR,
+        containing_type=None,
+        create_key=_descriptor._internal_create_key,
+        fields=[
+            _descriptor.FieldDescriptor(
+                name='message_set_wire_format', full_name='google.protobuf.MessageOptions.message_set_wire_format',
+                index=0,
+                number=1, type=8, cpp_type=7, label=1,
+                has_default_value=True, default_value=False,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='no_standard_descriptor_accessor',
+                full_name='google.protobuf.MessageOptions.no_standard_descriptor_accessor', index=1,
+                number=2, type=8, cpp_type=7, label=1,
+                has_default_value=True, default_value=False,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='deprecated', full_name='google.protobuf.MessageOptions.deprecated', index=2,
+                number=3, type=8, cpp_type=7, label=1,
+                has_default_value=True, default_value=False,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='map_entry', full_name='google.protobuf.MessageOptions.map_entry', index=3,
+                number=7, type=8, cpp_type=7, label=1,
+                has_default_value=False, default_value=False,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='uninterpreted_option', full_name='google.protobuf.MessageOptions.uninterpreted_option', index=4,
+                number=999, type=11, cpp_type=10, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        ],
+        extensions=[
+        ],
+        nested_types=[],
+        enum_types=[
+        ],
+        serialized_options=None,
+        is_extendable=True,
+        syntax='proto2',
+        extension_ranges=[(1000, 536870912), ],
+        oneofs=[
+        ],
+    )
+
+    _FIELDOPTIONS = _descriptor.Descriptor(
+        name='FieldOptions',
+        full_name='google.protobuf.FieldOptions',
+        filename=None,
+        file=DESCRIPTOR,
+        containing_type=None,
+        create_key=_descriptor._internal_create_key,
+        fields=[
+            _descriptor.FieldDescriptor(
+                name='ctype', full_name='google.protobuf.FieldOptions.ctype', index=0,
+                number=1, type=14, cpp_type=8, label=1,
+                has_default_value=True, default_value=0,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='packed', full_name='google.protobuf.FieldOptions.packed', index=1,
+                number=2, type=8, cpp_type=7, label=1,
+                has_default_value=False, default_value=False,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='jstype', full_name='google.protobuf.FieldOptions.jstype', index=2,
+                number=6, type=14, cpp_type=8, label=1,
+                has_default_value=True, default_value=0,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='lazy', full_name='google.protobuf.FieldOptions.lazy', index=3,
+                number=5, type=8, cpp_type=7, label=1,
+                has_default_value=True, default_value=False,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='unverified_lazy', full_name='google.protobuf.FieldOptions.unverified_lazy', index=4,
+                number=15, type=8, cpp_type=7, label=1,
+                has_default_value=True, default_value=False,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='deprecated', full_name='google.protobuf.FieldOptions.deprecated', index=5,
+                number=3, type=8, cpp_type=7, label=1,
+                has_default_value=True, default_value=False,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='weak', full_name='google.protobuf.FieldOptions.weak', index=6,
+                number=10, type=8, cpp_type=7, label=1,
+                has_default_value=True, default_value=False,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='uninterpreted_option', full_name='google.protobuf.FieldOptions.uninterpreted_option', index=7,
+                number=999, type=11, cpp_type=10, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        ],
+        extensions=[
+        ],
+        nested_types=[],
+        enum_types=[
+            _FIELDOPTIONS_CTYPE,
+            _FIELDOPTIONS_JSTYPE,
+        ],
+        serialized_options=None,
+        is_extendable=True,
+        syntax='proto2',
+        extension_ranges=[(1000, 536870912), ],
+        oneofs=[
+        ],
+    )
+
+    _ONEOFOPTIONS = _descriptor.Descriptor(
+        name='OneofOptions',
+        full_name='google.protobuf.OneofOptions',
+        filename=None,
+        file=DESCRIPTOR,
+        containing_type=None,
+        create_key=_descriptor._internal_create_key,
+        fields=[
+            _descriptor.FieldDescriptor(
+                name='uninterpreted_option', full_name='google.protobuf.OneofOptions.uninterpreted_option', index=0,
+                number=999, type=11, cpp_type=10, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        ],
+        extensions=[
+        ],
+        nested_types=[],
+        enum_types=[
+        ],
+        serialized_options=None,
+        is_extendable=True,
+        syntax='proto2',
+        extension_ranges=[(1000, 536870912), ],
+        oneofs=[
+        ],
+    )
+
+    _ENUMOPTIONS = _descriptor.Descriptor(
+        name='EnumOptions',
+        full_name='google.protobuf.EnumOptions',
+        filename=None,
+        file=DESCRIPTOR,
+        containing_type=None,
+        create_key=_descriptor._internal_create_key,
+        fields=[
+            _descriptor.FieldDescriptor(
+                name='allow_alias', full_name='google.protobuf.EnumOptions.allow_alias', index=0,
+                number=2, type=8, cpp_type=7, label=1,
+                has_default_value=False, default_value=False,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='deprecated', full_name='google.protobuf.EnumOptions.deprecated', index=1,
+                number=3, type=8, cpp_type=7, label=1,
+                has_default_value=True, default_value=False,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='uninterpreted_option', full_name='google.protobuf.EnumOptions.uninterpreted_option', index=2,
+                number=999, type=11, cpp_type=10, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        ],
+        extensions=[
+        ],
+        nested_types=[],
+        enum_types=[
+        ],
+        serialized_options=None,
+        is_extendable=True,
+        syntax='proto2',
+        extension_ranges=[(1000, 536870912), ],
+        oneofs=[
+        ],
+    )
+
+    _ENUMVALUEOPTIONS = _descriptor.Descriptor(
+        name='EnumValueOptions',
+        full_name='google.protobuf.EnumValueOptions',
+        filename=None,
+        file=DESCRIPTOR,
+        containing_type=None,
+        create_key=_descriptor._internal_create_key,
+        fields=[
+            _descriptor.FieldDescriptor(
+                name='deprecated', full_name='google.protobuf.EnumValueOptions.deprecated', index=0,
+                number=1, type=8, cpp_type=7, label=1,
+                has_default_value=True, default_value=False,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='uninterpreted_option', full_name='google.protobuf.EnumValueOptions.uninterpreted_option', index=1,
+                number=999, type=11, cpp_type=10, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        ],
+        extensions=[
+        ],
+        nested_types=[],
+        enum_types=[
+        ],
+        serialized_options=None,
+        is_extendable=True,
+        syntax='proto2',
+        extension_ranges=[(1000, 536870912), ],
+        oneofs=[
+        ],
+    )
+
+    _SERVICEOPTIONS = _descriptor.Descriptor(
+        name='ServiceOptions',
+        full_name='google.protobuf.ServiceOptions',
+        filename=None,
+        file=DESCRIPTOR,
+        containing_type=None,
+        create_key=_descriptor._internal_create_key,
+        fields=[
+            _descriptor.FieldDescriptor(
+                name='deprecated', full_name='google.protobuf.ServiceOptions.deprecated', index=0,
+                number=33, type=8, cpp_type=7, label=1,
+                has_default_value=True, default_value=False,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='uninterpreted_option', full_name='google.protobuf.ServiceOptions.uninterpreted_option', index=1,
+                number=999, type=11, cpp_type=10, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        ],
+        extensions=[
+        ],
+        nested_types=[],
+        enum_types=[
+        ],
+        serialized_options=None,
+        is_extendable=True,
+        syntax='proto2',
+        extension_ranges=[(1000, 536870912), ],
+        oneofs=[
+        ],
+    )
+
+    _METHODOPTIONS = _descriptor.Descriptor(
+        name='MethodOptions',
+        full_name='google.protobuf.MethodOptions',
+        filename=None,
+        file=DESCRIPTOR,
+        containing_type=None,
+        create_key=_descriptor._internal_create_key,
+        fields=[
+            _descriptor.FieldDescriptor(
+                name='deprecated', full_name='google.protobuf.MethodOptions.deprecated', index=0,
+                number=33, type=8, cpp_type=7, label=1,
+                has_default_value=True, default_value=False,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='idempotency_level', full_name='google.protobuf.MethodOptions.idempotency_level', index=1,
+                number=34, type=14, cpp_type=8, label=1,
+                has_default_value=True, default_value=0,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='uninterpreted_option', full_name='google.protobuf.MethodOptions.uninterpreted_option', index=2,
+                number=999, type=11, cpp_type=10, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        ],
+        extensions=[
+        ],
+        nested_types=[],
+        enum_types=[
+            _METHODOPTIONS_IDEMPOTENCYLEVEL,
+        ],
+        serialized_options=None,
+        is_extendable=True,
+        syntax='proto2',
+        extension_ranges=[(1000, 536870912), ],
+        oneofs=[
+        ],
+    )
+
+    _UNINTERPRETEDOPTION_NAMEPART = _descriptor.Descriptor(
+        name='NamePart',
+        full_name='google.protobuf.UninterpretedOption.NamePart',
+        filename=None,
+        file=DESCRIPTOR,
+        containing_type=None,
+        create_key=_descriptor._internal_create_key,
+        fields=[
+            _descriptor.FieldDescriptor(
+                name='name_part', full_name='google.protobuf.UninterpretedOption.NamePart.name_part', index=0,
+                number=1, type=9, cpp_type=9, label=2,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='is_extension', full_name='google.protobuf.UninterpretedOption.NamePart.is_extension', index=1,
+                number=2, type=8, cpp_type=7, label=2,
+                has_default_value=False, default_value=False,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        ],
+        extensions=[
+        ],
+        nested_types=[],
+        enum_types=[
+        ],
+        serialized_options=None,
+        is_extendable=False,
+        syntax='proto2',
+        extension_ranges=[],
+        oneofs=[
+        ],
+    )
+
+    _UNINTERPRETEDOPTION = _descriptor.Descriptor(
+        name='UninterpretedOption',
+        full_name='google.protobuf.UninterpretedOption',
+        filename=None,
+        file=DESCRIPTOR,
+        containing_type=None,
+        create_key=_descriptor._internal_create_key,
+        fields=[
+            _descriptor.FieldDescriptor(
+                name='name', full_name='google.protobuf.UninterpretedOption.name', index=0,
+                number=2, type=11, cpp_type=10, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='identifier_value', full_name='google.protobuf.UninterpretedOption.identifier_value', index=1,
+                number=3, type=9, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='positive_int_value', full_name='google.protobuf.UninterpretedOption.positive_int_value', index=2,
+                number=4, type=4, cpp_type=4, label=1,
+                has_default_value=False, default_value=0,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='negative_int_value', full_name='google.protobuf.UninterpretedOption.negative_int_value', index=3,
+                number=5, type=3, cpp_type=2, label=1,
+                has_default_value=False, default_value=0,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='double_value', full_name='google.protobuf.UninterpretedOption.double_value', index=4,
+                number=6, type=1, cpp_type=5, label=1,
+                has_default_value=False, default_value=float(0),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='string_value', full_name='google.protobuf.UninterpretedOption.string_value', index=5,
+                number=7, type=12, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"",
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='aggregate_value', full_name='google.protobuf.UninterpretedOption.aggregate_value', index=6,
+                number=8, type=9, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        ],
+        extensions=[
+        ],
+        nested_types=[_UNINTERPRETEDOPTION_NAMEPART, ],
+        enum_types=[
+        ],
+        serialized_options=None,
+        is_extendable=False,
+        syntax='proto2',
+        extension_ranges=[],
+        oneofs=[
+        ],
+    )
+
+    _SOURCECODEINFO_LOCATION = _descriptor.Descriptor(
+        name='Location',
+        full_name='google.protobuf.SourceCodeInfo.Location',
+        filename=None,
+        file=DESCRIPTOR,
+        containing_type=None,
+        create_key=_descriptor._internal_create_key,
+        fields=[
+            _descriptor.FieldDescriptor(
+                name='path', full_name='google.protobuf.SourceCodeInfo.Location.path', index=0,
+                number=1, type=5, cpp_type=1, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='span', full_name='google.protobuf.SourceCodeInfo.Location.span', index=1,
+                number=2, type=5, cpp_type=1, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='leading_comments', full_name='google.protobuf.SourceCodeInfo.Location.leading_comments', index=2,
+                number=3, type=9, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='trailing_comments', full_name='google.protobuf.SourceCodeInfo.Location.trailing_comments',
+                index=3,
+                number=4, type=9, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='leading_detached_comments',
+                full_name='google.protobuf.SourceCodeInfo.Location.leading_detached_comments', index=4,
+                number=6, type=9, cpp_type=9, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        ],
+        extensions=[
+        ],
+        nested_types=[],
+        enum_types=[
+        ],
+        serialized_options=None,
+        is_extendable=False,
+        syntax='proto2',
+        extension_ranges=[],
+        oneofs=[
+        ],
+    )
+
+    _SOURCECODEINFO = _descriptor.Descriptor(
+        name='SourceCodeInfo',
+        full_name='google.protobuf.SourceCodeInfo',
+        filename=None,
+        file=DESCRIPTOR,
+        containing_type=None,
+        create_key=_descriptor._internal_create_key,
+        fields=[
+            _descriptor.FieldDescriptor(
+                name='location', full_name='google.protobuf.SourceCodeInfo.location', index=0,
+                number=1, type=11, cpp_type=10, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        ],
+        extensions=[
+        ],
+        nested_types=[_SOURCECODEINFO_LOCATION, ],
+        enum_types=[
+        ],
+        serialized_options=None,
+        is_extendable=False,
+        syntax='proto2',
+        extension_ranges=[],
+        oneofs=[
+        ],
+    )
+
+    _GENERATEDCODEINFO_ANNOTATION = _descriptor.Descriptor(
+        name='Annotation',
+        full_name='google.protobuf.GeneratedCodeInfo.Annotation',
+        filename=None,
+        file=DESCRIPTOR,
+        containing_type=None,
+        create_key=_descriptor._internal_create_key,
+        fields=[
+            _descriptor.FieldDescriptor(
+                name='path', full_name='google.protobuf.GeneratedCodeInfo.Annotation.path', index=0,
+                number=1, type=5, cpp_type=1, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='source_file', full_name='google.protobuf.GeneratedCodeInfo.Annotation.source_file', index=1,
+                number=2, type=9, cpp_type=9, label=1,
+                has_default_value=False, default_value=b"".decode('utf-8'),
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='begin', full_name='google.protobuf.GeneratedCodeInfo.Annotation.begin', index=2,
+                number=3, type=5, cpp_type=1, label=1,
+                has_default_value=False, default_value=0,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+            _descriptor.FieldDescriptor(
+                name='end', full_name='google.protobuf.GeneratedCodeInfo.Annotation.end', index=3,
+                number=4, type=5, cpp_type=1, label=1,
+                has_default_value=False, default_value=0,
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        ],
+        extensions=[
+        ],
+        nested_types=[],
+        enum_types=[
+        ],
+        serialized_options=None,
+        is_extendable=False,
+        syntax='proto2',
+        extension_ranges=[],
+        oneofs=[
+        ],
+    )
+
+    _GENERATEDCODEINFO = _descriptor.Descriptor(
+        name='GeneratedCodeInfo',
+        full_name='google.protobuf.GeneratedCodeInfo',
+        filename=None,
+        file=DESCRIPTOR,
+        containing_type=None,
+        create_key=_descriptor._internal_create_key,
+        fields=[
+            _descriptor.FieldDescriptor(
+                name='annotation', full_name='google.protobuf.GeneratedCodeInfo.annotation', index=0,
+                number=1, type=11, cpp_type=10, label=3,
+                has_default_value=False, default_value=[],
+                message_type=None, enum_type=None, containing_type=None,
+                is_extension=False, extension_scope=None,
+                serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        ],
+        extensions=[
+        ],
+        nested_types=[_GENERATEDCODEINFO_ANNOTATION, ],
+        enum_types=[
+        ],
+        serialized_options=None,
+        is_extendable=False,
+        syntax='proto2',
+        extension_ranges=[],
+        oneofs=[
+        ],
+    )
+
+    _FILEDESCRIPTORSET.fields_by_name['file'].message_type = _FILEDESCRIPTORPROTO
+    _FILEDESCRIPTORPROTO.fields_by_name['message_type'].message_type = _DESCRIPTORPROTO
+    _FILEDESCRIPTORPROTO.fields_by_name['enum_type'].message_type = _ENUMDESCRIPTORPROTO
+    _FILEDESCRIPTORPROTO.fields_by_name['service'].message_type = _SERVICEDESCRIPTORPROTO
+    _FILEDESCRIPTORPROTO.fields_by_name['extension'].message_type = _FIELDDESCRIPTORPROTO
+    _FILEDESCRIPTORPROTO.fields_by_name['options'].message_type = _FILEOPTIONS
+    _FILEDESCRIPTORPROTO.fields_by_name['source_code_info'].message_type = _SOURCECODEINFO
+    _DESCRIPTORPROTO_EXTENSIONRANGE.fields_by_name['options'].message_type = _EXTENSIONRANGEOPTIONS
+    _DESCRIPTORPROTO_EXTENSIONRANGE.containing_type = _DESCRIPTORPROTO
+    _DESCRIPTORPROTO_RESERVEDRANGE.containing_type = _DESCRIPTORPROTO
+    _DESCRIPTORPROTO.fields_by_name['field'].message_type = _FIELDDESCRIPTORPROTO
+    _DESCRIPTORPROTO.fields_by_name['extension'].message_type = _FIELDDESCRIPTORPROTO
+    _DESCRIPTORPROTO.fields_by_name['nested_type'].message_type = _DESCRIPTORPROTO
+    _DESCRIPTORPROTO.fields_by_name['enum_type'].message_type = _ENUMDESCRIPTORPROTO
+    _DESCRIPTORPROTO.fields_by_name['extension_range'].message_type = _DESCRIPTORPROTO_EXTENSIONRANGE
+    _DESCRIPTORPROTO.fields_by_name['oneof_decl'].message_type = _ONEOFDESCRIPTORPROTO
+    _DESCRIPTORPROTO.fields_by_name['options'].message_type = _MESSAGEOPTIONS
+    _DESCRIPTORPROTO.fields_by_name['reserved_range'].message_type = _DESCRIPTORPROTO_RESERVEDRANGE
+    _EXTENSIONRANGEOPTIONS.fields_by_name['uninterpreted_option'].message_type = _UNINTERPRETEDOPTION
+    _FIELDDESCRIPTORPROTO.fields_by_name['label'].enum_type = _FIELDDESCRIPTORPROTO_LABEL
+    _FIELDDESCRIPTORPROTO.fields_by_name['type'].enum_type = _FIELDDESCRIPTORPROTO_TYPE
+    _FIELDDESCRIPTORPROTO.fields_by_name['options'].message_type = _FIELDOPTIONS
+    _FIELDDESCRIPTORPROTO_TYPE.containing_type = _FIELDDESCRIPTORPROTO
+    _FIELDDESCRIPTORPROTO_LABEL.containing_type = _FIELDDESCRIPTORPROTO
+    _ONEOFDESCRIPTORPROTO.fields_by_name['options'].message_type = _ONEOFOPTIONS
+    _ENUMDESCRIPTORPROTO_ENUMRESERVEDRANGE.containing_type = _ENUMDESCRIPTORPROTO
+    _ENUMDESCRIPTORPROTO.fields_by_name['value'].message_type = _ENUMVALUEDESCRIPTORPROTO
+    _ENUMDESCRIPTORPROTO.fields_by_name['options'].message_type = _ENUMOPTIONS
+    _ENUMDESCRIPTORPROTO.fields_by_name['reserved_range'].message_type = _ENUMDESCRIPTORPROTO_ENUMRESERVEDRANGE
+    _ENUMVALUEDESCRIPTORPROTO.fields_by_name['options'].message_type = _ENUMVALUEOPTIONS
+    _SERVICEDESCRIPTORPROTO.fields_by_name['method'].message_type = _METHODDESCRIPTORPROTO
+    _SERVICEDESCRIPTORPROTO.fields_by_name['options'].message_type = _SERVICEOPTIONS
+    _METHODDESCRIPTORPROTO.fields_by_name['options'].message_type = _METHODOPTIONS
+    _FILEOPTIONS.fields_by_name['optimize_for'].enum_type = _FILEOPTIONS_OPTIMIZEMODE
+    _FILEOPTIONS.fields_by_name['uninterpreted_option'].message_type = _UNINTERPRETEDOPTION
+    _FILEOPTIONS_OPTIMIZEMODE.containing_type = _FILEOPTIONS
+    _MESSAGEOPTIONS.fields_by_name['uninterpreted_option'].message_type = _UNINTERPRETEDOPTION
+    _FIELDOPTIONS.fields_by_name['ctype'].enum_type = _FIELDOPTIONS_CTYPE
+    _FIELDOPTIONS.fields_by_name['jstype'].enum_type = _FIELDOPTIONS_JSTYPE
+    _FIELDOPTIONS.fields_by_name['uninterpreted_option'].message_type = _UNINTERPRETEDOPTION
+    _FIELDOPTIONS_CTYPE.containing_type = _FIELDOPTIONS
+    _FIELDOPTIONS_JSTYPE.containing_type = _FIELDOPTIONS
+    _ONEOFOPTIONS.fields_by_name['uninterpreted_option'].message_type = _UNINTERPRETEDOPTION
+    _ENUMOPTIONS.fields_by_name['uninterpreted_option'].message_type = _UNINTERPRETEDOPTION
+    _ENUMVALUEOPTIONS.fields_by_name['uninterpreted_option'].message_type = _UNINTERPRETEDOPTION
+    _SERVICEOPTIONS.fields_by_name['uninterpreted_option'].message_type = _UNINTERPRETEDOPTION
+    _METHODOPTIONS.fields_by_name['idempotency_level'].enum_type = _METHODOPTIONS_IDEMPOTENCYLEVEL
+    _METHODOPTIONS.fields_by_name['uninterpreted_option'].message_type = _UNINTERPRETEDOPTION
+    _METHODOPTIONS_IDEMPOTENCYLEVEL.containing_type = _METHODOPTIONS
+    _UNINTERPRETEDOPTION_NAMEPART.containing_type = _UNINTERPRETEDOPTION
+    _UNINTERPRETEDOPTION.fields_by_name['name'].message_type = _UNINTERPRETEDOPTION_NAMEPART
+    _SOURCECODEINFO_LOCATION.containing_type = _SOURCECODEINFO
+    _SOURCECODEINFO.fields_by_name['location'].message_type = _SOURCECODEINFO_LOCATION
+    _GENERATEDCODEINFO_ANNOTATION.containing_type = _GENERATEDCODEINFO
+    _GENERATEDCODEINFO.fields_by_name['annotation'].message_type = _GENERATEDCODEINFO_ANNOTATION
+    DESCRIPTOR.message_types_by_name['FileDescriptorSet'] = _FILEDESCRIPTORSET
+    DESCRIPTOR.message_types_by_name['FileDescriptorProto'] = _FILEDESCRIPTORPROTO
+    DESCRIPTOR.message_types_by_name['DescriptorProto'] = _DESCRIPTORPROTO
+    DESCRIPTOR.message_types_by_name['ExtensionRangeOptions'] = _EXTENSIONRANGEOPTIONS
+    DESCRIPTOR.message_types_by_name['FieldDescriptorProto'] = _FIELDDESCRIPTORPROTO
+    DESCRIPTOR.message_types_by_name['OneofDescriptorProto'] = _ONEOFDESCRIPTORPROTO
+    DESCRIPTOR.message_types_by_name['EnumDescriptorProto'] = _ENUMDESCRIPTORPROTO
+    DESCRIPTOR.message_types_by_name['EnumValueDescriptorProto'] = _ENUMVALUEDESCRIPTORPROTO
+    DESCRIPTOR.message_types_by_name['ServiceDescriptorProto'] = _SERVICEDESCRIPTORPROTO
+    DESCRIPTOR.message_types_by_name['MethodDescriptorProto'] = _METHODDESCRIPTORPROTO
+    DESCRIPTOR.message_types_by_name['FileOptions'] = _FILEOPTIONS
+    DESCRIPTOR.message_types_by_name['MessageOptions'] = _MESSAGEOPTIONS
+    DESCRIPTOR.message_types_by_name['FieldOptions'] = _FIELDOPTIONS
+    DESCRIPTOR.message_types_by_name['OneofOptions'] = _ONEOFOPTIONS
+    DESCRIPTOR.message_types_by_name['EnumOptions'] = _ENUMOPTIONS
+    DESCRIPTOR.message_types_by_name['EnumValueOptions'] = _ENUMVALUEOPTIONS
+    DESCRIPTOR.message_types_by_name['ServiceOptions'] = _SERVICEOPTIONS
+    DESCRIPTOR.message_types_by_name['MethodOptions'] = _METHODOPTIONS
+    DESCRIPTOR.message_types_by_name['UninterpretedOption'] = _UNINTERPRETEDOPTION
+    DESCRIPTOR.message_types_by_name['SourceCodeInfo'] = _SOURCECODEINFO
+    DESCRIPTOR.message_types_by_name['GeneratedCodeInfo'] = _GENERATEDCODEINFO
+    _sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+else:
+    _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.descriptor_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+    DESCRIPTOR._options = None
+    _FILEDESCRIPTORSET._serialized_start = 53
+    _FILEDESCRIPTORSET._serialized_end = 124
+    _FILEDESCRIPTORPROTO._serialized_start = 127
+    _FILEDESCRIPTORPROTO._serialized_end = 602
+    _DESCRIPTORPROTO._serialized_start = 605
+    _DESCRIPTORPROTO._serialized_end = 1286
+    _DESCRIPTORPROTO_EXTENSIONRANGE._serialized_start = 1140
+    _DESCRIPTORPROTO_EXTENSIONRANGE._serialized_end = 1241
+    _DESCRIPTORPROTO_RESERVEDRANGE._serialized_start = 1243
+    _DESCRIPTORPROTO_RESERVEDRANGE._serialized_end = 1286
+    _EXTENSIONRANGEOPTIONS._serialized_start = 1288
+    _EXTENSIONRANGEOPTIONS._serialized_end = 1391
+    _FIELDDESCRIPTORPROTO._serialized_start = 1394
+    _FIELDDESCRIPTORPROTO._serialized_end = 2119
+    _FIELDDESCRIPTORPROTO_TYPE._serialized_start = 1740
+    _FIELDDESCRIPTORPROTO_TYPE._serialized_end = 2050
+    _FIELDDESCRIPTORPROTO_LABEL._serialized_start = 2052
+    _FIELDDESCRIPTORPROTO_LABEL._serialized_end = 2119
+    _ONEOFDESCRIPTORPROTO._serialized_start = 2121
+    _ONEOFDESCRIPTORPROTO._serialized_end = 2205
+    _ENUMDESCRIPTORPROTO._serialized_start = 2208
+    _ENUMDESCRIPTORPROTO._serialized_end = 2500
+    _ENUMDESCRIPTORPROTO_ENUMRESERVEDRANGE._serialized_start = 2453
+    _ENUMDESCRIPTORPROTO_ENUMRESERVEDRANGE._serialized_end = 2500
+    _ENUMVALUEDESCRIPTORPROTO._serialized_start = 2502
+    _ENUMVALUEDESCRIPTORPROTO._serialized_end = 2610
+    _SERVICEDESCRIPTORPROTO._serialized_start = 2613
+    _SERVICEDESCRIPTORPROTO._serialized_end = 2757
+    _METHODDESCRIPTORPROTO._serialized_start = 2760
+    _METHODDESCRIPTORPROTO._serialized_end = 2953
+    _FILEOPTIONS._serialized_start = 2956
+    _FILEOPTIONS._serialized_end = 3761
+    _FILEOPTIONS_OPTIMIZEMODE._serialized_start = 3686
+    _FILEOPTIONS_OPTIMIZEMODE._serialized_end = 3744
+    _MESSAGEOPTIONS._serialized_start = 3764
+    _MESSAGEOPTIONS._serialized_end = 4024
+    _FIELDOPTIONS._serialized_start = 4027
+    _FIELDOPTIONS._serialized_end = 4473
+    _FIELDOPTIONS_CTYPE._serialized_start = 4354
+    _FIELDOPTIONS_CTYPE._serialized_end = 4401
+    _FIELDOPTIONS_JSTYPE._serialized_start = 4403
+    _FIELDOPTIONS_JSTYPE._serialized_end = 4456
+    _ONEOFOPTIONS._serialized_start = 4475
+    _ONEOFOPTIONS._serialized_end = 4569
+    _ENUMOPTIONS._serialized_start = 4572
+    _ENUMOPTIONS._serialized_end = 4719
+    _ENUMVALUEOPTIONS._serialized_start = 4721
+    _ENUMVALUEOPTIONS._serialized_end = 4846
+    _SERVICEOPTIONS._serialized_start = 4848
+    _SERVICEOPTIONS._serialized_end = 4971
+    _METHODOPTIONS._serialized_start = 4974
+    _METHODOPTIONS._serialized_end = 5275
+    _METHODOPTIONS_IDEMPOTENCYLEVEL._serialized_start = 5184
+    _METHODOPTIONS_IDEMPOTENCYLEVEL._serialized_end = 5264
+    _UNINTERPRETEDOPTION._serialized_start = 5278
+    _UNINTERPRETEDOPTION._serialized_end = 5564
+    _UNINTERPRETEDOPTION_NAMEPART._serialized_start = 5513
+    _UNINTERPRETEDOPTION_NAMEPART._serialized_end = 5564
+    _SOURCECODEINFO._serialized_start = 5567
+    _SOURCECODEINFO._serialized_end = 5780
+    _SOURCECODEINFO_LOCATION._serialized_start = 5646
+    _SOURCECODEINFO_LOCATION._serialized_end = 5780
+    _GENERATEDCODEINFO._serialized_start = 5783
+    _GENERATEDCODEINFO._serialized_end = 5950
+    _GENERATEDCODEINFO_ANNOTATION._serialized_start = 5871
+    _GENERATEDCODEINFO_ANNOTATION._serialized_end = 5950
+# @@protoc_insertion_point(module_scope)
diff --git a/lark_channel/ws/pb/google/protobuf/descriptor_pool.py b/lark_channel/ws/pb/google/protobuf/descriptor_pool.py
new file mode 100644
index 0000000..16d0408
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/descriptor_pool.py
@@ -0,0 +1,1294 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+# https://developers.google.com/protocol-buffers/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""Provides DescriptorPool to use as a container for proto2 descriptors.
+
+The DescriptorPool is used in conjection with a DescriptorDatabase to maintain
+a collection of protocol buffer descriptors for use when dynamically creating
+message types at runtime.
+
+For most applications protocol buffers should be used via modules generated by
+the protocol buffer compiler tool. This should only be used when the type of
+protocol buffers used in an application or library cannot be predetermined.
+
+Below is a straightforward example on how to use this class::
+
+  pool = DescriptorPool()
+  file_descriptor_protos = [ ... ]
+  for file_descriptor_proto in file_descriptor_protos:
+    pool.Add(file_descriptor_proto)
+  my_message_descriptor = pool.FindMessageTypeByName('some.package.MessageType')
+
+The message descriptor can be used in conjunction with the message_factory
+module in order to create a protocol buffer class that can be encoded and
+decoded.
+
+If you want to get a Python class for the specified proto, use the
+helper functions inside google.protobuf.message_factory
+directly instead of this class.
+"""
+
+__author__ = 'matthewtoia@google.com (Matt Toia)'
+
+import collections
+import warnings
+
+from lark_channel.ws.pb.google.protobuf import descriptor
+from lark_channel.ws.pb.google.protobuf import descriptor_database
+from lark_channel.ws.pb.google.protobuf import text_encoding
+
+_USE_C_DESCRIPTORS = descriptor._USE_C_DESCRIPTORS  # pylint: disable=protected-access
+
+
+def _Deprecated(func):
+    """Mark functions as deprecated."""
+
+    def NewFunc(*args, **kwargs):
+        warnings.warn(
+            'Call to deprecated function %s(). Note: Do add unlinked descriptors '
+            'to descriptor_pool is wrong. Use Add() or AddSerializedFile() '
+            'instead.' % func.__name__,
+            category=DeprecationWarning)
+        return func(*args, **kwargs)
+
+    NewFunc.__name__ = func.__name__
+    NewFunc.__doc__ = func.__doc__
+    NewFunc.__dict__.update(func.__dict__)
+    return NewFunc
+
+
+def _NormalizeFullyQualifiedName(name):
+    """Remove leading period from fully-qualified type name.
+
+    Due to b/13860351 in descriptor_database.py, types in the root namespace are
+    generated with a leading period. This function removes that prefix.
+
+    Args:
+      name (str): The fully-qualified symbol name.
+
+    Returns:
+      str: The normalized fully-qualified symbol name.
+    """
+    return name.lstrip('.')
+
+
+def _OptionsOrNone(descriptor_proto):
+    """Returns the value of the field `options`, or None if it is not set."""
+    if descriptor_proto.HasField('options'):
+        return descriptor_proto.options
+    else:
+        return None
+
+
+def _IsMessageSetExtension(field):
+    return (field.is_extension and
+            field.containing_type.has_options and
+            field.containing_type.GetOptions().message_set_wire_format and
+            field.type == descriptor.FieldDescriptor.TYPE_MESSAGE and
+            field.label == descriptor.FieldDescriptor.LABEL_OPTIONAL)
+
+
+class DescriptorPool(object):
+    """A collection of protobufs dynamically constructed by descriptor protos."""
+
+    if _USE_C_DESCRIPTORS:
+        def __new__(cls, descriptor_db=None):
+            # pylint: disable=protected-access
+            return descriptor._message.DescriptorPool(descriptor_db)
+
+    def __init__(self, descriptor_db=None):
+        """Initializes a Pool of proto buffs.
+
+        The descriptor_db argument to the constructor is provided to allow
+        specialized file descriptor proto lookup code to be triggered on demand. An
+        example would be an implementation which will read and compile a file
+        specified in a call to FindFileByName() and not require the call to Add()
+        at all. Results from this database will be cached internally here as well.
+
+        Args:
+          descriptor_db: A secondary source of file descriptors.
+        """
+
+        self._internal_db = descriptor_database.DescriptorDatabase()
+        self._descriptor_db = descriptor_db
+        self._descriptors = {}
+        self._enum_descriptors = {}
+        self._service_descriptors = {}
+        self._file_descriptors = {}
+        self._toplevel_extensions = {}
+        # TODO(jieluo): Remove _file_desc_by_toplevel_extension after
+        # maybe year 2020 for compatibility issue (with 3.4.1 only).
+        self._file_desc_by_toplevel_extension = {}
+        self._top_enum_values = {}
+        # We store extensions in two two-level mappings: The first key is the
+        # descriptor of the message being extended, the second key is the extension
+        # full name or its tag number.
+        self._extensions_by_name = collections.defaultdict(dict)
+        self._extensions_by_number = collections.defaultdict(dict)
+
+    def _CheckConflictRegister(self, desc, desc_name, file_name):
+        """Check if the descriptor name conflicts with another of the same name.
+
+        Args:
+          desc: Descriptor of a message, enum, service, extension or enum value.
+          desc_name (str): the full name of desc.
+          file_name (str): The file name of descriptor.
+        """
+        for register, descriptor_type in [
+            (self._descriptors, descriptor.Descriptor),
+            (self._enum_descriptors, descriptor.EnumDescriptor),
+            (self._service_descriptors, descriptor.ServiceDescriptor),
+            (self._toplevel_extensions, descriptor.FieldDescriptor),
+            (self._top_enum_values, descriptor.EnumValueDescriptor)]:
+            if desc_name in register:
+                old_desc = register[desc_name]
+                if isinstance(old_desc, descriptor.EnumValueDescriptor):
+                    old_file = old_desc.type.file.name
+                else:
+                    old_file = old_desc.file.name
+
+                if not isinstance(desc, descriptor_type) or (
+                        old_file != file_name):
+                    error_msg = ('Conflict register for file "' + file_name +
+                                 '": ' + desc_name +
+                                 ' is already defined in file "' +
+                                 old_file + '". Please fix the conflict by adding '
+                                            'package name on the proto file, or use different '
+                                            'name for the duplication.')
+                    if isinstance(desc, descriptor.EnumValueDescriptor):
+                        error_msg += ('\nNote: enum values appear as '
+                                      'siblings of the enum type instead of '
+                                      'children of it.')
+
+                    raise TypeError(error_msg)
+
+                return
+
+    def Add(self, file_desc_proto):
+        """Adds the FileDescriptorProto and its types to this pool.
+
+        Args:
+          file_desc_proto (FileDescriptorProto): The file descriptor to add.
+        """
+
+        self._internal_db.Add(file_desc_proto)
+
+    def AddSerializedFile(self, serialized_file_desc_proto):
+        """Adds the FileDescriptorProto and its types to this pool.
+
+        Args:
+          serialized_file_desc_proto (bytes): A bytes string, serialization of the
+            :class:`FileDescriptorProto` to add.
+
+        Returns:
+          FileDescriptor: Descriptor for the added file.
+        """
+
+        # pylint: disable=g-import-not-at-top
+        from lark_channel.ws.pb.google.protobuf import descriptor_pb2
+        file_desc_proto = descriptor_pb2.FileDescriptorProto.FromString(
+            serialized_file_desc_proto)
+        file_desc = self._ConvertFileProtoToFileDescriptor(file_desc_proto)
+        file_desc.serialized_pb = serialized_file_desc_proto
+        return file_desc
+
+    # Add Descriptor to descriptor pool is dreprecated. Please use Add()
+    # or AddSerializedFile() to add a FileDescriptorProto instead.
+    @_Deprecated
+    def AddDescriptor(self, desc):
+        self._AddDescriptor(desc)
+
+    # Never call this method. It is for internal usage only.
+    def _AddDescriptor(self, desc):
+        """Adds a Descriptor to the pool, non-recursively.
+
+        If the Descriptor contains nested messages or enums, the caller must
+        explicitly register them. This method also registers the FileDescriptor
+        associated with the message.
+
+        Args:
+          desc: A Descriptor.
+        """
+        if not isinstance(desc, descriptor.Descriptor):
+            raise TypeError('Expected instance of descriptor.Descriptor.')
+
+        self._CheckConflictRegister(desc, desc.full_name, desc.file.name)
+
+        self._descriptors[desc.full_name] = desc
+        self._AddFileDescriptor(desc.file)
+
+    # Add EnumDescriptor to descriptor pool is dreprecated. Please use Add()
+    # or AddSerializedFile() to add a FileDescriptorProto instead.
+    @_Deprecated
+    def AddEnumDescriptor(self, enum_desc):
+        self._AddEnumDescriptor(enum_desc)
+
+    # Never call this method. It is for internal usage only.
+    def _AddEnumDescriptor(self, enum_desc):
+        """Adds an EnumDescriptor to the pool.
+
+        This method also registers the FileDescriptor associated with the enum.
+
+        Args:
+          enum_desc: An EnumDescriptor.
+        """
+
+        if not isinstance(enum_desc, descriptor.EnumDescriptor):
+            raise TypeError('Expected instance of descriptor.EnumDescriptor.')
+
+        file_name = enum_desc.file.name
+        self._CheckConflictRegister(enum_desc, enum_desc.full_name, file_name)
+        self._enum_descriptors[enum_desc.full_name] = enum_desc
+
+        # Top enum values need to be indexed.
+        # Count the number of dots to see whether the enum is toplevel or nested
+        # in a message. We cannot use enum_desc.containing_type at this stage.
+        if enum_desc.file.package:
+            top_level = (enum_desc.full_name.count('.')
+                         - enum_desc.file.package.count('.') == 1)
+        else:
+            top_level = enum_desc.full_name.count('.') == 0
+        if top_level:
+            file_name = enum_desc.file.name
+            package = enum_desc.file.package
+            for enum_value in enum_desc.values:
+                full_name = _NormalizeFullyQualifiedName(
+                    '.'.join((package, enum_value.name)))
+                self._CheckConflictRegister(enum_value, full_name, file_name)
+                self._top_enum_values[full_name] = enum_value
+        self._AddFileDescriptor(enum_desc.file)
+
+    # Add ServiceDescriptor to descriptor pool is dreprecated. Please use Add()
+    # or AddSerializedFile() to add a FileDescriptorProto instead.
+    @_Deprecated
+    def AddServiceDescriptor(self, service_desc):
+        self._AddServiceDescriptor(service_desc)
+
+    # Never call this method. It is for internal usage only.
+    def _AddServiceDescriptor(self, service_desc):
+        """Adds a ServiceDescriptor to the pool.
+
+        Args:
+          service_desc: A ServiceDescriptor.
+        """
+
+        if not isinstance(service_desc, descriptor.ServiceDescriptor):
+            raise TypeError('Expected instance of descriptor.ServiceDescriptor.')
+
+        self._CheckConflictRegister(service_desc, service_desc.full_name,
+                                    service_desc.file.name)
+        self._service_descriptors[service_desc.full_name] = service_desc
+
+    # Add ExtensionDescriptor to descriptor pool is dreprecated. Please use Add()
+    # or AddSerializedFile() to add a FileDescriptorProto instead.
+    @_Deprecated
+    def AddExtensionDescriptor(self, extension):
+        self._AddExtensionDescriptor(extension)
+
+    # Never call this method. It is for internal usage only.
+    def _AddExtensionDescriptor(self, extension):
+        """Adds a FieldDescriptor describing an extension to the pool.
+
+        Args:
+          extension: A FieldDescriptor.
+
+        Raises:
+          AssertionError: when another extension with the same number extends the
+            same message.
+          TypeError: when the specified extension is not a
+            descriptor.FieldDescriptor.
+        """
+        if not (isinstance(extension, descriptor.FieldDescriptor) and
+                extension.is_extension):
+            raise TypeError('Expected an extension descriptor.')
+
+        if extension.extension_scope is None:
+            self._toplevel_extensions[extension.full_name] = extension
+
+        try:
+            existing_desc = self._extensions_by_number[
+                extension.containing_type][extension.number]
+        except KeyError:
+            pass
+        else:
+            if extension is not existing_desc:
+                raise AssertionError(
+                    'Extensions "%s" and "%s" both try to extend message type "%s" '
+                    'with field number %d.' %
+                    (extension.full_name, existing_desc.full_name,
+                     extension.containing_type.full_name, extension.number))
+
+        self._extensions_by_number[extension.containing_type][
+            extension.number] = extension
+        self._extensions_by_name[extension.containing_type][
+            extension.full_name] = extension
+
+        # Also register MessageSet extensions with the type name.
+        if _IsMessageSetExtension(extension):
+            self._extensions_by_name[extension.containing_type][
+                extension.message_type.full_name] = extension
+
+    @_Deprecated
+    def AddFileDescriptor(self, file_desc):
+        self._InternalAddFileDescriptor(file_desc)
+
+    # Never call this method. It is for internal usage only.
+    def _InternalAddFileDescriptor(self, file_desc):
+        """Adds a FileDescriptor to the pool, non-recursively.
+
+        If the FileDescriptor contains messages or enums, the caller must explicitly
+        register them.
+
+        Args:
+          file_desc: A FileDescriptor.
+        """
+
+        self._AddFileDescriptor(file_desc)
+        # TODO(jieluo): This is a temporary solution for FieldDescriptor.file.
+        # FieldDescriptor.file is added in code gen. Remove this solution after
+        # maybe 2020 for compatibility reason (with 3.4.1 only).
+        for extension in file_desc.extensions_by_name.values():
+            self._file_desc_by_toplevel_extension[
+                extension.full_name] = file_desc
+
+    def _AddFileDescriptor(self, file_desc):
+        """Adds a FileDescriptor to the pool, non-recursively.
+
+        If the FileDescriptor contains messages or enums, the caller must explicitly
+        register them.
+
+        Args:
+          file_desc: A FileDescriptor.
+        """
+
+        if not isinstance(file_desc, descriptor.FileDescriptor):
+            raise TypeError('Expected instance of descriptor.FileDescriptor.')
+        self._file_descriptors[file_desc.name] = file_desc
+
+    def FindFileByName(self, file_name):
+        """Gets a FileDescriptor by file name.
+
+        Args:
+          file_name (str): The path to the file to get a descriptor for.
+
+        Returns:
+          FileDescriptor: The descriptor for the named file.
+
+        Raises:
+          KeyError: if the file cannot be found in the pool.
+        """
+
+        try:
+            return self._file_descriptors[file_name]
+        except KeyError:
+            pass
+
+        try:
+            file_proto = self._internal_db.FindFileByName(file_name)
+        except KeyError as error:
+            if self._descriptor_db:
+                file_proto = self._descriptor_db.FindFileByName(file_name)
+            else:
+                raise error
+        if not file_proto:
+            raise KeyError('Cannot find a file named %s' % file_name)
+        return self._ConvertFileProtoToFileDescriptor(file_proto)
+
+    def FindFileContainingSymbol(self, symbol):
+        """Gets the FileDescriptor for the file containing the specified symbol.
+
+        Args:
+          symbol (str): The name of the symbol to search for.
+
+        Returns:
+          FileDescriptor: Descriptor for the file that contains the specified
+          symbol.
+
+        Raises:
+          KeyError: if the file cannot be found in the pool.
+        """
+
+        symbol = _NormalizeFullyQualifiedName(symbol)
+        try:
+            return self._InternalFindFileContainingSymbol(symbol)
+        except KeyError:
+            pass
+
+        try:
+            # Try fallback database. Build and find again if possible.
+            self._FindFileContainingSymbolInDb(symbol)
+            return self._InternalFindFileContainingSymbol(symbol)
+        except KeyError:
+            raise KeyError('Cannot find a file containing %s' % symbol)
+
+    def _InternalFindFileContainingSymbol(self, symbol):
+        """Gets the already built FileDescriptor containing the specified symbol.
+
+        Args:
+          symbol (str): The name of the symbol to search for.
+
+        Returns:
+          FileDescriptor: Descriptor for the file that contains the specified
+          symbol.
+
+        Raises:
+          KeyError: if the file cannot be found in the pool.
+        """
+        try:
+            return self._descriptors[symbol].file
+        except KeyError:
+            pass
+
+        try:
+            return self._enum_descriptors[symbol].file
+        except KeyError:
+            pass
+
+        try:
+            return self._service_descriptors[symbol].file
+        except KeyError:
+            pass
+
+        try:
+            return self._top_enum_values[symbol].type.file
+        except KeyError:
+            pass
+
+        try:
+            return self._file_desc_by_toplevel_extension[symbol]
+        except KeyError:
+            pass
+
+        # Try fields, enum values and nested extensions inside a message.
+        top_name, _, sub_name = symbol.rpartition('.')
+        try:
+            message = self.FindMessageTypeByName(top_name)
+            assert (sub_name in message.extensions_by_name or
+                    sub_name in message.fields_by_name or
+                    sub_name in message.enum_values_by_name)
+            return message.file
+        except (KeyError, AssertionError):
+            raise KeyError('Cannot find a file containing %s' % symbol)
+
+    def FindMessageTypeByName(self, full_name):
+        """Loads the named descriptor from the pool.
+
+        Args:
+          full_name (str): The full name of the descriptor to load.
+
+        Returns:
+          Descriptor: The descriptor for the named type.
+
+        Raises:
+          KeyError: if the message cannot be found in the pool.
+        """
+
+        full_name = _NormalizeFullyQualifiedName(full_name)
+        if full_name not in self._descriptors:
+            self._FindFileContainingSymbolInDb(full_name)
+        return self._descriptors[full_name]
+
+    def FindEnumTypeByName(self, full_name):
+        """Loads the named enum descriptor from the pool.
+
+        Args:
+          full_name (str): The full name of the enum descriptor to load.
+
+        Returns:
+          EnumDescriptor: The enum descriptor for the named type.
+
+        Raises:
+          KeyError: if the enum cannot be found in the pool.
+        """
+
+        full_name = _NormalizeFullyQualifiedName(full_name)
+        if full_name not in self._enum_descriptors:
+            self._FindFileContainingSymbolInDb(full_name)
+        return self._enum_descriptors[full_name]
+
+    def FindFieldByName(self, full_name):
+        """Loads the named field descriptor from the pool.
+
+        Args:
+          full_name (str): The full name of the field descriptor to load.
+
+        Returns:
+          FieldDescriptor: The field descriptor for the named field.
+
+        Raises:
+          KeyError: if the field cannot be found in the pool.
+        """
+        full_name = _NormalizeFullyQualifiedName(full_name)
+        message_name, _, field_name = full_name.rpartition('.')
+        message_descriptor = self.FindMessageTypeByName(message_name)
+        return message_descriptor.fields_by_name[field_name]
+
+    def FindOneofByName(self, full_name):
+        """Loads the named oneof descriptor from the pool.
+
+        Args:
+          full_name (str): The full name of the oneof descriptor to load.
+
+        Returns:
+          OneofDescriptor: The oneof descriptor for the named oneof.
+
+        Raises:
+          KeyError: if the oneof cannot be found in the pool.
+        """
+        full_name = _NormalizeFullyQualifiedName(full_name)
+        message_name, _, oneof_name = full_name.rpartition('.')
+        message_descriptor = self.FindMessageTypeByName(message_name)
+        return message_descriptor.oneofs_by_name[oneof_name]
+
+    def FindExtensionByName(self, full_name):
+        """Loads the named extension descriptor from the pool.
+
+        Args:
+          full_name (str): The full name of the extension descriptor to load.
+
+        Returns:
+          FieldDescriptor: The field descriptor for the named extension.
+
+        Raises:
+          KeyError: if the extension cannot be found in the pool.
+        """
+        full_name = _NormalizeFullyQualifiedName(full_name)
+        try:
+            # The proto compiler does not give any link between the FileDescriptor
+            # and top-level extensions unless the FileDescriptorProto is added to
+            # the DescriptorDatabase, but this can impact memory usage.
+            # So we registered these extensions by name explicitly.
+            return self._toplevel_extensions[full_name]
+        except KeyError:
+            pass
+        message_name, _, extension_name = full_name.rpartition('.')
+        try:
+            # Most extensions are nested inside a message.
+            scope = self.FindMessageTypeByName(message_name)
+        except KeyError:
+            # Some extensions are defined at file scope.
+            scope = self._FindFileContainingSymbolInDb(full_name)
+        return scope.extensions_by_name[extension_name]
+
+    def FindExtensionByNumber(self, message_descriptor, number):
+        """Gets the extension of the specified message with the specified number.
+
+        Extensions have to be registered to this pool by calling :func:`Add` or
+        :func:`AddExtensionDescriptor`.
+
+        Args:
+          message_descriptor (Descriptor): descriptor of the extended message.
+          number (int): Number of the extension field.
+
+        Returns:
+          FieldDescriptor: The descriptor for the extension.
+
+        Raises:
+          KeyError: when no extension with the given number is known for the
+            specified message.
+        """
+        try:
+            return self._extensions_by_number[message_descriptor][number]
+        except KeyError:
+            self._TryLoadExtensionFromDB(message_descriptor, number)
+            return self._extensions_by_number[message_descriptor][number]
+
+    def FindAllExtensions(self, message_descriptor):
+        """Gets all the known extensions of a given message.
+
+        Extensions have to be registered to this pool by build related
+        :func:`Add` or :func:`AddExtensionDescriptor`.
+
+        Args:
+          message_descriptor (Descriptor): Descriptor of the extended message.
+
+        Returns:
+          list[FieldDescriptor]: Field descriptors describing the extensions.
+        """
+        # Fallback to descriptor db if FindAllExtensionNumbers is provided.
+        if self._descriptor_db and hasattr(
+                self._descriptor_db, 'FindAllExtensionNumbers'):
+            full_name = message_descriptor.full_name
+            all_numbers = self._descriptor_db.FindAllExtensionNumbers(full_name)
+            for number in all_numbers:
+                if number in self._extensions_by_number[message_descriptor]:
+                    continue
+                self._TryLoadExtensionFromDB(message_descriptor, number)
+
+        return list(self._extensions_by_number[message_descriptor].values())
+
+    def _TryLoadExtensionFromDB(self, message_descriptor, number):
+        """Try to Load extensions from descriptor db.
+
+        Args:
+          message_descriptor: descriptor of the extended message.
+          number: the extension number that needs to be loaded.
+        """
+        if not self._descriptor_db:
+            return
+        # Only supported when FindFileContainingExtension is provided.
+        if not hasattr(
+                self._descriptor_db, 'FindFileContainingExtension'):
+            return
+
+        full_name = message_descriptor.full_name
+        file_proto = self._descriptor_db.FindFileContainingExtension(
+            full_name, number)
+
+        if file_proto is None:
+            return
+
+        try:
+            self._ConvertFileProtoToFileDescriptor(file_proto)
+        except:
+            warn_msg = ('Unable to load proto file %s for extension number %d.' %
+                        (file_proto.name, number))
+            warnings.warn(warn_msg, RuntimeWarning)
+
+    def FindServiceByName(self, full_name):
+        """Loads the named service descriptor from the pool.
+
+        Args:
+          full_name (str): The full name of the service descriptor to load.
+
+        Returns:
+          ServiceDescriptor: The service descriptor for the named service.
+
+        Raises:
+          KeyError: if the service cannot be found in the pool.
+        """
+        full_name = _NormalizeFullyQualifiedName(full_name)
+        if full_name not in self._service_descriptors:
+            self._FindFileContainingSymbolInDb(full_name)
+        return self._service_descriptors[full_name]
+
+    def FindMethodByName(self, full_name):
+        """Loads the named service method descriptor from the pool.
+
+        Args:
+          full_name (str): The full name of the method descriptor to load.
+
+        Returns:
+          MethodDescriptor: The method descriptor for the service method.
+
+        Raises:
+          KeyError: if the method cannot be found in the pool.
+        """
+        full_name = _NormalizeFullyQualifiedName(full_name)
+        service_name, _, method_name = full_name.rpartition('.')
+        service_descriptor = self.FindServiceByName(service_name)
+        return service_descriptor.methods_by_name[method_name]
+
+    def _FindFileContainingSymbolInDb(self, symbol):
+        """Finds the file in descriptor DB containing the specified symbol.
+
+        Args:
+          symbol (str): The name of the symbol to search for.
+
+        Returns:
+          FileDescriptor: The file that contains the specified symbol.
+
+        Raises:
+          KeyError: if the file cannot be found in the descriptor database.
+        """
+        try:
+            file_proto = self._internal_db.FindFileContainingSymbol(symbol)
+        except KeyError as error:
+            if self._descriptor_db:
+                file_proto = self._descriptor_db.FindFileContainingSymbol(symbol)
+            else:
+                raise error
+        if not file_proto:
+            raise KeyError('Cannot find a file containing %s' % symbol)
+        return self._ConvertFileProtoToFileDescriptor(file_proto)
+
+    def _ConvertFileProtoToFileDescriptor(self, file_proto):
+        """Creates a FileDescriptor from a proto or returns a cached copy.
+
+        This method also has the side effect of loading all the symbols found in
+        the file into the appropriate dictionaries in the pool.
+
+        Args:
+          file_proto: The proto to convert.
+
+        Returns:
+          A FileDescriptor matching the passed in proto.
+        """
+        if file_proto.name not in self._file_descriptors:
+            built_deps = list(self._GetDeps(file_proto.dependency))
+            direct_deps = [self.FindFileByName(n) for n in file_proto.dependency]
+            public_deps = [direct_deps[i] for i in file_proto.public_dependency]
+
+            file_descriptor = descriptor.FileDescriptor(
+                pool=self,
+                name=file_proto.name,
+                package=file_proto.package,
+                syntax=file_proto.syntax,
+                options=_OptionsOrNone(file_proto),
+                serialized_pb=file_proto.SerializeToString(),
+                dependencies=direct_deps,
+                public_dependencies=public_deps,
+                # pylint: disable=protected-access
+                create_key=descriptor._internal_create_key)
+            scope = {}
+
+            # This loop extracts all the message and enum types from all the
+            # dependencies of the file_proto. This is necessary to create the
+            # scope of available message types when defining the passed in
+            # file proto.
+            for dependency in built_deps:
+                scope.update(self._ExtractSymbols(
+                    dependency.message_types_by_name.values()))
+                scope.update((_PrefixWithDot(enum.full_name), enum)
+                             for enum in dependency.enum_types_by_name.values())
+
+            for message_type in file_proto.message_type:
+                message_desc = self._ConvertMessageDescriptor(
+                    message_type, file_proto.package, file_descriptor, scope,
+                    file_proto.syntax)
+                file_descriptor.message_types_by_name[message_desc.name] = (
+                    message_desc)
+
+            for enum_type in file_proto.enum_type:
+                file_descriptor.enum_types_by_name[enum_type.name] = (
+                    self._ConvertEnumDescriptor(enum_type, file_proto.package,
+                                                file_descriptor, None, scope, True))
+
+            for index, extension_proto in enumerate(file_proto.extension):
+                extension_desc = self._MakeFieldDescriptor(
+                    extension_proto, file_proto.package, index, file_descriptor,
+                    is_extension=True)
+                extension_desc.containing_type = self._GetTypeFromScope(
+                    file_descriptor.package, extension_proto.extendee, scope)
+                self._SetFieldType(extension_proto, extension_desc,
+                                   file_descriptor.package, scope)
+                file_descriptor.extensions_by_name[extension_desc.name] = (
+                    extension_desc)
+                self._file_desc_by_toplevel_extension[extension_desc.full_name] = (
+                    file_descriptor)
+
+            for desc_proto in file_proto.message_type:
+                self._SetAllFieldTypes(file_proto.package, desc_proto, scope)
+
+            if file_proto.package:
+                desc_proto_prefix = _PrefixWithDot(file_proto.package)
+            else:
+                desc_proto_prefix = ''
+
+            for desc_proto in file_proto.message_type:
+                desc = self._GetTypeFromScope(
+                    desc_proto_prefix, desc_proto.name, scope)
+                file_descriptor.message_types_by_name[desc_proto.name] = desc
+
+            for index, service_proto in enumerate(file_proto.service):
+                file_descriptor.services_by_name[service_proto.name] = (
+                    self._MakeServiceDescriptor(service_proto, index, scope,
+                                                file_proto.package, file_descriptor))
+
+            self._file_descriptors[file_proto.name] = file_descriptor
+
+        # Add extensions to the pool
+        file_desc = self._file_descriptors[file_proto.name]
+        for extension in file_desc.extensions_by_name.values():
+            self._AddExtensionDescriptor(extension)
+        for message_type in file_desc.message_types_by_name.values():
+            for extension in message_type.extensions:
+                self._AddExtensionDescriptor(extension)
+
+        return file_desc
+
+    def _ConvertMessageDescriptor(self, desc_proto, package=None, file_desc=None,
+                                  scope=None, syntax=None):
+        """Adds the proto to the pool in the specified package.
+
+        Args:
+          desc_proto: The descriptor_pb2.DescriptorProto protobuf message.
+          package: The package the proto should be located in.
+          file_desc: The file containing this message.
+          scope: Dict mapping short and full symbols to message and enum types.
+          syntax: string indicating syntax of the file ("proto2" or "proto3")
+
+        Returns:
+          The added descriptor.
+        """
+
+        if package:
+            desc_name = '.'.join((package, desc_proto.name))
+        else:
+            desc_name = desc_proto.name
+
+        if file_desc is None:
+            file_name = None
+        else:
+            file_name = file_desc.name
+
+        if scope is None:
+            scope = {}
+
+        nested = [
+            self._ConvertMessageDescriptor(
+                nested, desc_name, file_desc, scope, syntax)
+            for nested in desc_proto.nested_type]
+        enums = [
+            self._ConvertEnumDescriptor(enum, desc_name, file_desc, None,
+                                        scope, False)
+            for enum in desc_proto.enum_type]
+        fields = [self._MakeFieldDescriptor(field, desc_name, index, file_desc)
+                  for index, field in enumerate(desc_proto.field)]
+        extensions = [
+            self._MakeFieldDescriptor(extension, desc_name, index, file_desc,
+                                      is_extension=True)
+            for index, extension in enumerate(desc_proto.extension)]
+        oneofs = [
+            # pylint: disable=g-complex-comprehension
+            descriptor.OneofDescriptor(
+                desc.name,
+                '.'.join((desc_name, desc.name)),
+                index,
+                None,
+                [],
+                _OptionsOrNone(desc),
+                # pylint: disable=protected-access
+                create_key=descriptor._internal_create_key)
+            for index, desc in enumerate(desc_proto.oneof_decl)
+        ]
+        extension_ranges = [(r.start, r.end) for r in desc_proto.extension_range]
+        if extension_ranges:
+            is_extendable = True
+        else:
+            is_extendable = False
+        desc = descriptor.Descriptor(
+            name=desc_proto.name,
+            full_name=desc_name,
+            filename=file_name,
+            containing_type=None,
+            fields=fields,
+            oneofs=oneofs,
+            nested_types=nested,
+            enum_types=enums,
+            extensions=extensions,
+            options=_OptionsOrNone(desc_proto),
+            is_extendable=is_extendable,
+            extension_ranges=extension_ranges,
+            file=file_desc,
+            serialized_start=None,
+            serialized_end=None,
+            syntax=syntax,
+            # pylint: disable=protected-access
+            create_key=descriptor._internal_create_key)
+        for nested in desc.nested_types:
+            nested.containing_type = desc
+        for enum in desc.enum_types:
+            enum.containing_type = desc
+        for field_index, field_desc in enumerate(desc_proto.field):
+            if field_desc.HasField('oneof_index'):
+                oneof_index = field_desc.oneof_index
+                oneofs[oneof_index].fields.append(fields[field_index])
+                fields[field_index].containing_oneof = oneofs[oneof_index]
+
+        scope[_PrefixWithDot(desc_name)] = desc
+        self._CheckConflictRegister(desc, desc.full_name, desc.file.name)
+        self._descriptors[desc_name] = desc
+        return desc
+
+    def _ConvertEnumDescriptor(self, enum_proto, package=None, file_desc=None,
+                               containing_type=None, scope=None, top_level=False):
+        """Make a protobuf EnumDescriptor given an EnumDescriptorProto protobuf.
+
+        Args:
+          enum_proto: The descriptor_pb2.EnumDescriptorProto protobuf message.
+          package: Optional package name for the new message EnumDescriptor.
+          file_desc: The file containing the enum descriptor.
+          containing_type: The type containing this enum.
+          scope: Scope containing available types.
+          top_level: If True, the enum is a top level symbol. If False, the enum
+              is defined inside a message.
+
+        Returns:
+          The added descriptor
+        """
+
+        if package:
+            enum_name = '.'.join((package, enum_proto.name))
+        else:
+            enum_name = enum_proto.name
+
+        if file_desc is None:
+            file_name = None
+        else:
+            file_name = file_desc.name
+
+        values = [self._MakeEnumValueDescriptor(value, index)
+                  for index, value in enumerate(enum_proto.value)]
+        desc = descriptor.EnumDescriptor(name=enum_proto.name,
+                                         full_name=enum_name,
+                                         filename=file_name,
+                                         file=file_desc,
+                                         values=values,
+                                         containing_type=containing_type,
+                                         options=_OptionsOrNone(enum_proto),
+                                         # pylint: disable=protected-access
+                                         create_key=descriptor._internal_create_key)
+        scope['.%s' % enum_name] = desc
+        self._CheckConflictRegister(desc, desc.full_name, desc.file.name)
+        self._enum_descriptors[enum_name] = desc
+
+        # Add top level enum values.
+        if top_level:
+            for value in values:
+                full_name = _NormalizeFullyQualifiedName(
+                    '.'.join((package, value.name)))
+                self._CheckConflictRegister(value, full_name, file_name)
+                self._top_enum_values[full_name] = value
+
+        return desc
+
+    def _MakeFieldDescriptor(self, field_proto, message_name, index,
+                             file_desc, is_extension=False):
+        """Creates a field descriptor from a FieldDescriptorProto.
+
+        For message and enum type fields, this method will do a look up
+        in the pool for the appropriate descriptor for that type. If it
+        is unavailable, it will fall back to the _source function to
+        create it. If this type is still unavailable, construction will
+        fail.
+
+        Args:
+          field_proto: The proto describing the field.
+          message_name: The name of the containing message.
+          index: Index of the field
+          file_desc: The file containing the field descriptor.
+          is_extension: Indication that this field is for an extension.
+
+        Returns:
+          An initialized FieldDescriptor object
+        """
+
+        if message_name:
+            full_name = '.'.join((message_name, field_proto.name))
+        else:
+            full_name = field_proto.name
+
+        if field_proto.json_name:
+            json_name = field_proto.json_name
+        else:
+            json_name = None
+
+        return descriptor.FieldDescriptor(
+            name=field_proto.name,
+            full_name=full_name,
+            index=index,
+            number=field_proto.number,
+            type=field_proto.type,
+            cpp_type=None,
+            message_type=None,
+            enum_type=None,
+            containing_type=None,
+            label=field_proto.label,
+            has_default_value=False,
+            default_value=None,
+            is_extension=is_extension,
+            extension_scope=None,
+            options=_OptionsOrNone(field_proto),
+            json_name=json_name,
+            file=file_desc,
+            # pylint: disable=protected-access
+            create_key=descriptor._internal_create_key)
+
+    def _SetAllFieldTypes(self, package, desc_proto, scope):
+        """Sets all the descriptor's fields's types.
+
+        This method also sets the containing types on any extensions.
+
+        Args:
+          package: The current package of desc_proto.
+          desc_proto: The message descriptor to update.
+          scope: Enclosing scope of available types.
+        """
+
+        package = _PrefixWithDot(package)
+
+        main_desc = self._GetTypeFromScope(package, desc_proto.name, scope)
+
+        if package == '.':
+            nested_package = _PrefixWithDot(desc_proto.name)
+        else:
+            nested_package = '.'.join([package, desc_proto.name])
+
+        for field_proto, field_desc in zip(desc_proto.field, main_desc.fields):
+            self._SetFieldType(field_proto, field_desc, nested_package, scope)
+
+        for extension_proto, extension_desc in (
+                zip(desc_proto.extension, main_desc.extensions)):
+            extension_desc.containing_type = self._GetTypeFromScope(
+                nested_package, extension_proto.extendee, scope)
+            self._SetFieldType(extension_proto, extension_desc, nested_package, scope)
+
+        for nested_type in desc_proto.nested_type:
+            self._SetAllFieldTypes(nested_package, nested_type, scope)
+
+    def _SetFieldType(self, field_proto, field_desc, package, scope):
+        """Sets the field's type, cpp_type, message_type and enum_type.
+
+        Args:
+          field_proto: Data about the field in proto format.
+          field_desc: The descriptor to modify.
+          package: The package the field's container is in.
+          scope: Enclosing scope of available types.
+        """
+        if field_proto.type_name:
+            desc = self._GetTypeFromScope(package, field_proto.type_name, scope)
+        else:
+            desc = None
+
+        if not field_proto.HasField('type'):
+            if isinstance(desc, descriptor.Descriptor):
+                field_proto.type = descriptor.FieldDescriptor.TYPE_MESSAGE
+            else:
+                field_proto.type = descriptor.FieldDescriptor.TYPE_ENUM
+
+        field_desc.cpp_type = descriptor.FieldDescriptor.ProtoTypeToCppProtoType(
+            field_proto.type)
+
+        if (field_proto.type == descriptor.FieldDescriptor.TYPE_MESSAGE
+                or field_proto.type == descriptor.FieldDescriptor.TYPE_GROUP):
+            field_desc.message_type = desc
+
+        if field_proto.type == descriptor.FieldDescriptor.TYPE_ENUM:
+            field_desc.enum_type = desc
+
+        if field_proto.label == descriptor.FieldDescriptor.LABEL_REPEATED:
+            field_desc.has_default_value = False
+            field_desc.default_value = []
+        elif field_proto.HasField('default_value'):
+            field_desc.has_default_value = True
+            if (field_proto.type == descriptor.FieldDescriptor.TYPE_DOUBLE or
+                    field_proto.type == descriptor.FieldDescriptor.TYPE_FLOAT):
+                field_desc.default_value = float(field_proto.default_value)
+            elif field_proto.type == descriptor.FieldDescriptor.TYPE_STRING:
+                field_desc.default_value = field_proto.default_value
+            elif field_proto.type == descriptor.FieldDescriptor.TYPE_BOOL:
+                field_desc.default_value = field_proto.default_value.lower() == 'true'
+            elif field_proto.type == descriptor.FieldDescriptor.TYPE_ENUM:
+                field_desc.default_value = field_desc.enum_type.values_by_name[
+                    field_proto.default_value].number
+            elif field_proto.type == descriptor.FieldDescriptor.TYPE_BYTES:
+                field_desc.default_value = text_encoding.CUnescape(
+                    field_proto.default_value)
+            elif field_proto.type == descriptor.FieldDescriptor.TYPE_MESSAGE:
+                field_desc.default_value = None
+            else:
+                # All other types are of the "int" type.
+                field_desc.default_value = int(field_proto.default_value)
+        else:
+            field_desc.has_default_value = False
+            if (field_proto.type == descriptor.FieldDescriptor.TYPE_DOUBLE or
+                    field_proto.type == descriptor.FieldDescriptor.TYPE_FLOAT):
+                field_desc.default_value = 0.0
+            elif field_proto.type == descriptor.FieldDescriptor.TYPE_STRING:
+                field_desc.default_value = u''
+            elif field_proto.type == descriptor.FieldDescriptor.TYPE_BOOL:
+                field_desc.default_value = False
+            elif field_proto.type == descriptor.FieldDescriptor.TYPE_ENUM:
+                field_desc.default_value = field_desc.enum_type.values[0].number
+            elif field_proto.type == descriptor.FieldDescriptor.TYPE_BYTES:
+                field_desc.default_value = b''
+            elif field_proto.type == descriptor.FieldDescriptor.TYPE_MESSAGE:
+                field_desc.default_value = None
+            elif field_proto.type == descriptor.FieldDescriptor.TYPE_GROUP:
+                field_desc.default_value = None
+            else:
+                # All other types are of the "int" type.
+                field_desc.default_value = 0
+
+        field_desc.type = field_proto.type
+
+    def _MakeEnumValueDescriptor(self, value_proto, index):
+        """Creates a enum value descriptor object from a enum value proto.
+
+        Args:
+          value_proto: The proto describing the enum value.
+          index: The index of the enum value.
+
+        Returns:
+          An initialized EnumValueDescriptor object.
+        """
+
+        return descriptor.EnumValueDescriptor(
+            name=value_proto.name,
+            index=index,
+            number=value_proto.number,
+            options=_OptionsOrNone(value_proto),
+            type=None,
+            # pylint: disable=protected-access
+            create_key=descriptor._internal_create_key)
+
+    def _MakeServiceDescriptor(self, service_proto, service_index, scope,
+                               package, file_desc):
+        """Make a protobuf ServiceDescriptor given a ServiceDescriptorProto.
+
+        Args:
+          service_proto: The descriptor_pb2.ServiceDescriptorProto protobuf message.
+          service_index: The index of the service in the File.
+          scope: Dict mapping short and full symbols to message and enum types.
+          package: Optional package name for the new message EnumDescriptor.
+          file_desc: The file containing the service descriptor.
+
+        Returns:
+          The added descriptor.
+        """
+
+        if package:
+            service_name = '.'.join((package, service_proto.name))
+        else:
+            service_name = service_proto.name
+
+        methods = [self._MakeMethodDescriptor(method_proto, service_name, package,
+                                              scope, index)
+                   for index, method_proto in enumerate(service_proto.method)]
+        desc = descriptor.ServiceDescriptor(
+            name=service_proto.name,
+            full_name=service_name,
+            index=service_index,
+            methods=methods,
+            options=_OptionsOrNone(service_proto),
+            file=file_desc,
+            # pylint: disable=protected-access
+            create_key=descriptor._internal_create_key)
+        self._CheckConflictRegister(desc, desc.full_name, desc.file.name)
+        self._service_descriptors[service_name] = desc
+        return desc
+
+    def _MakeMethodDescriptor(self, method_proto, service_name, package, scope,
+                              index):
+        """Creates a method descriptor from a MethodDescriptorProto.
+
+        Args:
+          method_proto: The proto describing the method.
+          service_name: The name of the containing service.
+          package: Optional package name to look up for types.
+          scope: Scope containing available types.
+          index: Index of the method in the service.
+
+        Returns:
+          An initialized MethodDescriptor object.
+        """
+        full_name = '.'.join((service_name, method_proto.name))
+        input_type = self._GetTypeFromScope(
+            package, method_proto.input_type, scope)
+        output_type = self._GetTypeFromScope(
+            package, method_proto.output_type, scope)
+        return descriptor.MethodDescriptor(
+            name=method_proto.name,
+            full_name=full_name,
+            index=index,
+            containing_service=None,
+            input_type=input_type,
+            output_type=output_type,
+            client_streaming=method_proto.client_streaming,
+            server_streaming=method_proto.server_streaming,
+            options=_OptionsOrNone(method_proto),
+            # pylint: disable=protected-access
+            create_key=descriptor._internal_create_key)
+
+    def _ExtractSymbols(self, descriptors):
+        """Pulls out all the symbols from descriptor protos.
+
+        Args:
+          descriptors: The messages to extract descriptors from.
+        Yields:
+          A two element tuple of the type name and descriptor object.
+        """
+
+        for desc in descriptors:
+            yield (_PrefixWithDot(desc.full_name), desc)
+            for symbol in self._ExtractSymbols(desc.nested_types):
+                yield symbol
+            for enum in desc.enum_types:
+                yield (_PrefixWithDot(enum.full_name), enum)
+
+    def _GetDeps(self, dependencies, visited=None):
+        """Recursively finds dependencies for file protos.
+
+        Args:
+          dependencies: The names of the files being depended on.
+          visited: The names of files already found.
+
+        Yields:
+          Each direct and indirect dependency.
+        """
+
+        visited = visited or set()
+        for dependency in dependencies:
+            if dependency not in visited:
+                visited.add(dependency)
+                dep_desc = self.FindFileByName(dependency)
+                yield dep_desc
+                public_files = [d.name for d in dep_desc.public_dependencies]
+                yield from self._GetDeps(public_files, visited)
+
+    def _GetTypeFromScope(self, package, type_name, scope):
+        """Finds a given type name in the current scope.
+
+        Args:
+          package: The package the proto should be located in.
+          type_name: The name of the type to be found in the scope.
+          scope: Dict mapping short and full symbols to message and enum types.
+
+        Returns:
+          The descriptor for the requested type.
+        """
+        if type_name not in scope:
+            components = _PrefixWithDot(package).split('.')
+            while components:
+                possible_match = '.'.join(components + [type_name])
+                if possible_match in scope:
+                    type_name = possible_match
+                    break
+                else:
+                    components.pop(-1)
+        return scope[type_name]
+
+
+def _PrefixWithDot(name):
+    return name if name.startswith('.') else '.%s' % name
+
+
+if _USE_C_DESCRIPTORS:
+    # TODO(amauryfa): This pool could be constructed from Python code, when we
+    # support a flag like 'use_cpp_generated_pool=True'.
+    # pylint: disable=protected-access
+    _DEFAULT = descriptor._message.default_pool
+else:
+    _DEFAULT = DescriptorPool()
+
+
+def Default():
+    return _DEFAULT
diff --git a/lark_channel/ws/pb/google/protobuf/duration_pb2.py b/lark_channel/ws/pb/google/protobuf/duration_pb2.py
new file mode 100644
index 0000000..e3fadc0
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/duration_pb2.py
@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+# source: google/protobuf/duration.proto
+"""Generated protocol buffer code."""
+from lark_channel.ws.pb.google.protobuf.internal import builder as _builder
+from lark_channel.ws.pb.google.protobuf import descriptor as _descriptor
+from lark_channel.ws.pb.google.protobuf import descriptor_pool as _descriptor_pool
+from lark_channel.ws.pb.google.protobuf import symbol_database as _symbol_database
+
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(
+    b'\n\x1egoogle/protobuf/duration.proto\x12\x0fgoogle.protobuf\"*\n\x08\x44uration\x12\x0f\n\x07seconds\x18\x01 \x01(\x03\x12\r\n\x05nanos\x18\x02 \x01(\x05\x42\x83\x01\n\x13\x63om.google.protobufB\rDurationProtoP\x01Z1google.golang.org/protobuf/types/known/durationpb\xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesb\x06proto3')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.duration_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+    DESCRIPTOR._options = None
+    DESCRIPTOR._serialized_options = b'\n\023com.google.protobufB\rDurationProtoP\001Z1google.golang.org/protobuf/types/known/durationpb\370\001\001\242\002\003GPB\252\002\036Google.Protobuf.WellKnownTypes'
+    _DURATION._serialized_start = 51
+    _DURATION._serialized_end = 93
+# @@protoc_insertion_point(module_scope)
diff --git a/lark_channel/ws/pb/google/protobuf/empty_pb2.py b/lark_channel/ws/pb/google/protobuf/empty_pb2.py
new file mode 100644
index 0000000..bc86e1c
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/empty_pb2.py
@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+# source: google/protobuf/empty.proto
+"""Generated protocol buffer code."""
+from lark_channel.ws.pb.google.protobuf.internal import builder as _builder
+from lark_channel.ws.pb.google.protobuf import descriptor as _descriptor
+from lark_channel.ws.pb.google.protobuf import descriptor_pool as _descriptor_pool
+from lark_channel.ws.pb.google.protobuf import symbol_database as _symbol_database
+
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(
+    b'\n\x1bgoogle/protobuf/empty.proto\x12\x0fgoogle.protobuf\"\x07\n\x05\x45mptyB}\n\x13\x63om.google.protobufB\nEmptyProtoP\x01Z.google.golang.org/protobuf/types/known/emptypb\xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesb\x06proto3')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.empty_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+    DESCRIPTOR._options = None
+    DESCRIPTOR._serialized_options = b'\n\023com.google.protobufB\nEmptyProtoP\001Z.google.golang.org/protobuf/types/known/emptypb\370\001\001\242\002\003GPB\252\002\036Google.Protobuf.WellKnownTypes'
+    _EMPTY._serialized_start = 48
+    _EMPTY._serialized_end = 55
+# @@protoc_insertion_point(module_scope)
diff --git a/lark_channel/ws/pb/google/protobuf/field_mask_pb2.py b/lark_channel/ws/pb/google/protobuf/field_mask_pb2.py
new file mode 100644
index 0000000..6e38e33
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/field_mask_pb2.py
@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+# source: google/protobuf/field_mask.proto
+"""Generated protocol buffer code."""
+from lark_channel.ws.pb.google.protobuf.internal import builder as _builder
+from lark_channel.ws.pb.google.protobuf import descriptor as _descriptor
+from lark_channel.ws.pb.google.protobuf import descriptor_pool as _descriptor_pool
+from lark_channel.ws.pb.google.protobuf import symbol_database as _symbol_database
+
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(
+    b'\n google/protobuf/field_mask.proto\x12\x0fgoogle.protobuf\"\x1a\n\tFieldMask\x12\r\n\x05paths\x18\x01 \x03(\tB\x85\x01\n\x13\x63om.google.protobufB\x0e\x46ieldMaskProtoP\x01Z2google.golang.org/protobuf/types/known/fieldmaskpb\xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesb\x06proto3')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.field_mask_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+    DESCRIPTOR._options = None
+    DESCRIPTOR._serialized_options = b'\n\023com.google.protobufB\016FieldMaskProtoP\001Z2google.golang.org/protobuf/types/known/fieldmaskpb\370\001\001\242\002\003GPB\252\002\036Google.Protobuf.WellKnownTypes'
+    _FIELDMASK._serialized_start = 53
+    _FIELDMASK._serialized_end = 79
+# @@protoc_insertion_point(module_scope)
diff --git a/lark_channel/ws/pb/google/protobuf/internal/__init__.py b/lark_channel/ws/pb/google/protobuf/internal/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/lark_channel/ws/pb/google/protobuf/internal/api_implementation.cc b/lark_channel/ws/pb/google/protobuf/internal/api_implementation.cc
new file mode 100644
index 0000000..33f5b04
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/internal/api_implementation.cc
@@ -0,0 +1,111 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+namespace google {
+namespace protobuf {
+namespace python {
+
+// Version constant.
+// This is either 0 for python, 1 for CPP V1, 2 for CPP V2.
+//
+// 0 is default and is equivalent to
+//   PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION=python
+//
+// 1 is set with -DPYTHON_PROTO2_CPP_IMPL_V1 and is equivalent to
+//   PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION=cpp
+// and
+//   PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION_VERSION=1
+//
+// 2 is set with -DPYTHON_PROTO2_CPP_IMPL_V2 and is equivalent to
+//   PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION=cpp
+// and
+//   PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION_VERSION=2
+#ifdef PYTHON_PROTO2_CPP_IMPL_V1
+#error "PYTHON_PROTO2_CPP_IMPL_V1 is no longer supported."
+#else
+#ifdef PYTHON_PROTO2_CPP_IMPL_V2
+static int kImplVersion = 2;
+#else
+#ifdef PYTHON_PROTO2_PYTHON_IMPL
+static int kImplVersion = 0;
+#else
+
+static int kImplVersion = -1;  // -1 means "Unspecified by compiler flags".
+
+#endif  // PYTHON_PROTO2_PYTHON_IMPL
+#endif  // PYTHON_PROTO2_CPP_IMPL_V2
+#endif  // PYTHON_PROTO2_CPP_IMPL_V1
+
+static const char* kImplVersionName = "api_version";
+
+static const char* kModuleName = "_api_implementation";
+static const char kModuleDocstring[] =
+    "_api_implementation is a module that exposes compile-time constants that\n"
+    "determine the default API implementation to use for Python proto2.\n"
+    "\n"
+    "It complements api_implementation.py by setting defaults using "
+    "compile-time\n"
+    "constants defined in C, such that one can set defaults at compilation\n"
+    "(e.g. with blaze flag --copt=-DPYTHON_PROTO2_CPP_IMPL_V2).";
+
+static struct PyModuleDef _module = {PyModuleDef_HEAD_INIT,
+                                     kModuleName,
+                                     kModuleDocstring,
+                                     -1,
+                                     nullptr,
+                                     nullptr,
+                                     nullptr,
+                                     nullptr,
+                                     nullptr};
+
+extern "C" {
+PyMODINIT_FUNC PyInit__api_implementation() {
+  PyObject* module = PyModule_Create(&_module);
+  if (module == nullptr) {
+    return nullptr;
+  }
+
+  // Adds the module variable "api_version".
+  if (PyModule_AddIntConstant(module, const_cast<char*>(kImplVersionName),
+                              kImplVersion)) {
+    Py_DECREF(module);
+    return nullptr;
+  }
+
+  return module;
+}
+}
+
+}  // namespace python
+}  // namespace protobuf
+}  // namespace google
diff --git a/lark_channel/ws/pb/google/protobuf/internal/api_implementation.py b/lark_channel/ws/pb/google/protobuf/internal/api_implementation.py
new file mode 100644
index 0000000..bd5d570
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/internal/api_implementation.py
@@ -0,0 +1,111 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+# https://developers.google.com/protocol-buffers/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""Determine which implementation of the protobuf API is used in this process.
+"""
+
+import os
+import sys
+import warnings
+
+try:
+    # pylint: disable=g-import-not-at-top
+    from lark_channel.ws.pb.google.protobuf.internal import _api_implementation
+
+    # The compile-time constants in the _api_implementation module can be used to
+    # switch to a certain implementation of the Python API at build time.
+    _api_version = _api_implementation.api_version
+except ImportError:
+    _api_version = -1  # Unspecified by compiler flags.
+
+if _api_version == 1:
+    raise ValueError('api_version=1 is no longer supported.')
+
+_default_implementation_type = ('cpp' if _api_version > 0 else 'python')
+
+# This environment variable can be used to switch to a certain implementation
+# of the Python API, overriding the compile-time constants in the
+# _api_implementation module. Right now only 'python' and 'cpp' are valid
+# values. Any other value will be ignored.
+_implementation_type = os.getenv('PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION',
+                                 _default_implementation_type)
+
+if _implementation_type != 'python':
+    _implementation_type = 'cpp'
+
+if 'PyPy' in sys.version and _implementation_type == 'cpp':
+    warnings.warn('PyPy does not work yet with cpp protocol buffers. '
+                  'Falling back to the python implementation.')
+    _implementation_type = 'python'
+
+# Detect if serialization should be deterministic by default
+try:
+    # The presence of this module in a build allows the proto implementation to
+    # be upgraded merely via build deps.
+    #
+    # NOTE: Merely importing this automatically enables deterministic proto
+    # serialization for C++ code, but we still need to export it as a boolean so
+    # that we can do the same for `_implementation_type == 'python'`.
+    #
+    # NOTE2: It is possible for C++ code to enable deterministic serialization by
+    # default _without_ affecting Python code, if the C++ implementation is not in
+    # use by this module.  That is intended behavior, so we don't actually expose
+    # this boolean outside of this module.
+    #
+    # pylint: disable=g-import-not-at-top,unused-import
+    from lark_channel.ws.pb.google.protobuf import enable_deterministic_proto_serialization
+
+    _python_deterministic_proto_serialization = True
+except ImportError:
+    _python_deterministic_proto_serialization = False
+
+
+# Usage of this function is discouraged. Clients shouldn't care which
+# implementation of the API is in use. Note that there is no guarantee
+# that differences between APIs will be maintained.
+# Please don't use this function if possible.
+def Type():
+    return _implementation_type
+
+
+def _SetType(implementation_type):
+    """Never use! Only for protobuf benchmark."""
+    global _implementation_type
+    _implementation_type = implementation_type
+
+
+# See comment on 'Type' above.
+def Version():
+    return 2
+
+
+# For internal use only
+def IsPythonDefaultSerializationDeterministic():
+    return _python_deterministic_proto_serialization
diff --git a/lark_channel/ws/pb/google/protobuf/internal/builder.py b/lark_channel/ws/pb/google/protobuf/internal/builder.py
new file mode 100644
index 0000000..701526f
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/internal/builder.py
@@ -0,0 +1,130 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+# https://developers.google.com/protocol-buffers/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""Builds descriptors, message classes and services for generated _pb2.py.
+
+This file is only called in python generated _pb2.py files. It builds
+descriptors, message classes and services that users can directly use
+in generated code.
+"""
+
+__author__ = 'jieluo@google.com (Jie Luo)'
+
+from lark_channel.ws.pb.google.protobuf.internal import enum_type_wrapper
+from lark_channel.ws.pb.google.protobuf import message as _message
+from lark_channel.ws.pb.google.protobuf import reflection as _reflection
+from lark_channel.ws.pb.google.protobuf import symbol_database as _symbol_database
+
+_sym_db = _symbol_database.Default()
+
+
+def BuildMessageAndEnumDescriptors(file_des, module):
+    """Builds message and enum descriptors.
+
+    Args:
+      file_des: FileDescriptor of the .proto file
+      module: Generated _pb2 module
+    """
+
+    def BuildNestedDescriptors(msg_des, prefix):
+        for (name, nested_msg) in msg_des.nested_types_by_name.items():
+            module_name = prefix + name.upper()
+            module[module_name] = nested_msg
+            BuildNestedDescriptors(nested_msg, module_name + '_')
+        for enum_des in msg_des.enum_types:
+            module[prefix + enum_des.name.upper()] = enum_des
+
+    for (name, msg_des) in file_des.message_types_by_name.items():
+        module_name = '_' + name.upper()
+        module[module_name] = msg_des
+        BuildNestedDescriptors(msg_des, module_name + '_')
+
+
+def BuildTopDescriptorsAndMessages(file_des, module_name, module):
+    """Builds top level descriptors and message classes.
+
+    Args:
+      file_des: FileDescriptor of the .proto file
+      module_name: str, the name of generated _pb2 module
+      module: Generated _pb2 module
+    """
+
+    def BuildMessage(msg_des):
+        create_dict = {}
+        for (name, nested_msg) in msg_des.nested_types_by_name.items():
+            create_dict[name] = BuildMessage(nested_msg)
+        create_dict['DESCRIPTOR'] = msg_des
+        create_dict['__module__'] = module_name
+        message_class = _reflection.GeneratedProtocolMessageType(
+            msg_des.name, (_message.Message,), create_dict)
+        _sym_db.RegisterMessage(message_class)
+        return message_class
+
+    # top level enums
+    for (name, enum_des) in file_des.enum_types_by_name.items():
+        module['_' + name.upper()] = enum_des
+        module[name] = enum_type_wrapper.EnumTypeWrapper(enum_des)
+        for enum_value in enum_des.values:
+            module[enum_value.name] = enum_value.number
+
+    # top level extensions
+    for (name, extension_des) in file_des.extensions_by_name.items():
+        module[name.upper() + '_FIELD_NUMBER'] = extension_des.number
+        module[name] = extension_des
+
+    # services
+    for (name, service) in file_des.services_by_name.items():
+        module['_' + name.upper()] = service
+
+    # Build messages.
+    for (name, msg_des) in file_des.message_types_by_name.items():
+        module[name] = BuildMessage(msg_des)
+
+
+def BuildServices(file_des, module_name, module):
+    """Builds services classes and services stub class.
+
+    Args:
+      file_des: FileDescriptor of the .proto file
+      module_name: str, the name of generated _pb2 module
+      module: Generated _pb2 module
+    """
+    # pylint: disable=g-import-not-at-top
+    from lark_channel.ws.pb.google.protobuf import service as _service
+    from lark_channel.ws.pb.google.protobuf import service_reflection
+    # pylint: enable=g-import-not-at-top
+    for (name, service) in file_des.services_by_name.items():
+        module[name] = service_reflection.GeneratedServiceType(
+            name, (_service.Service,),
+            dict(DESCRIPTOR=service, __module__=module_name))
+        stub_name = name + '_Stub'
+        module[stub_name] = service_reflection.GeneratedServiceStubType(
+            stub_name, (module[name],),
+            dict(DESCRIPTOR=service, __module__=module_name))
diff --git a/lark_channel/ws/pb/google/protobuf/internal/containers.py b/lark_channel/ws/pb/google/protobuf/internal/containers.py
new file mode 100644
index 0000000..53475be
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/internal/containers.py
@@ -0,0 +1,709 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+# https://developers.google.com/protocol-buffers/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""Contains container classes to represent different protocol buffer types.
+
+This file defines container classes which represent categories of protocol
+buffer field types which need extra maintenance. Currently these categories
+are:
+
+-   Repeated scalar fields - These are all repeated fields which aren't
+    composite (e.g. they are of simple types like int32, string, etc).
+-   Repeated composite fields - Repeated fields which are composite. This
+    includes groups and nested messages.
+"""
+
+import collections.abc
+import copy
+import pickle
+from typing import (
+    Any,
+    Iterable,
+    Iterator,
+    List,
+    MutableMapping,
+    MutableSequence,
+    NoReturn,
+    Optional,
+    Sequence,
+    TypeVar,
+    Union,
+    overload,
+)
+
+_T = TypeVar('_T')
+_K = TypeVar('_K')
+_V = TypeVar('_V')
+
+
+class BaseContainer(Sequence[_T]):
+    """Base container class."""
+
+    # Minimizes memory usage and disallows assignment to other attributes.
+    __slots__ = ['_message_listener', '_values']
+
+    def __init__(self, message_listener: Any) -> None:
+        """
+        Args:
+          message_listener: A MessageListener implementation.
+            The RepeatedScalarFieldContainer will call this object's
+            Modified() method when it is modified.
+        """
+        self._message_listener = message_listener
+        self._values = []
+
+    @overload
+    def __getitem__(self, key: int) -> _T:
+        ...
+
+    @overload
+    def __getitem__(self, key: slice) -> List[_T]:
+        ...
+
+    def __getitem__(self, key):
+        """Retrieves item by the specified key."""
+        return self._values[key]
+
+    def __len__(self) -> int:
+        """Returns the number of elements in the container."""
+        return len(self._values)
+
+    def __ne__(self, other: Any) -> bool:
+        """Checks if another instance isn't equal to this one."""
+        # The concrete classes should define __eq__.
+        return not self == other
+
+    __hash__ = None
+
+    def __repr__(self) -> str:
+        return repr(self._values)
+
+    def sort(self, *args, **kwargs) -> None:
+        # Continue to support the old sort_function keyword argument.
+        # This is expected to be a rare occurrence, so use LBYL to avoid
+        # the overhead of actually catching KeyError.
+        if 'sort_function' in kwargs:
+            kwargs['cmp'] = kwargs.pop('sort_function')
+        self._values.sort(*args, **kwargs)
+
+    def reverse(self) -> None:
+        self._values.reverse()
+
+
+# TODO(slebedev): Remove this. BaseContainer does *not* conform to
+# MutableSequence, only its subclasses do.
+collections.abc.MutableSequence.register(BaseContainer)
+
+
+class RepeatedScalarFieldContainer(BaseContainer[_T], MutableSequence[_T]):
+    """Simple, type-checked, list-like container for holding repeated scalars."""
+
+    # Disallows assignment to other attributes.
+    __slots__ = ['_type_checker']
+
+    def __init__(
+            self,
+            message_listener: Any,
+            type_checker: Any,
+    ) -> None:
+        """Args:
+
+          message_listener: A MessageListener implementation. The
+          RepeatedScalarFieldContainer will call this object's Modified() method
+          when it is modified.
+          type_checker: A type_checkers.ValueChecker instance to run on elements
+          inserted into this container.
+        """
+        super().__init__(message_listener)
+        self._type_checker = type_checker
+
+    def append(self, value: _T) -> None:
+        """Appends an item to the list. Similar to list.append()."""
+        self._values.append(self._type_checker.CheckValue(value))
+        if not self._message_listener.dirty:
+            self._message_listener.Modified()
+
+    def insert(self, key: int, value: _T) -> None:
+        """Inserts the item at the specified position. Similar to list.insert()."""
+        self._values.insert(key, self._type_checker.CheckValue(value))
+        if not self._message_listener.dirty:
+            self._message_listener.Modified()
+
+    def extend(self, elem_seq: Iterable[_T]) -> None:
+        """Extends by appending the given iterable. Similar to list.extend()."""
+        if elem_seq is None:
+            return
+        try:
+            elem_seq_iter = iter(elem_seq)
+        except TypeError:
+            if not elem_seq:
+                # silently ignore falsy inputs :-/.
+                # TODO(ptucker): Deprecate this behavior. b/18413862
+                return
+            raise
+
+        new_values = [self._type_checker.CheckValue(elem) for elem in elem_seq_iter]
+        if new_values:
+            self._values.extend(new_values)
+        self._message_listener.Modified()
+
+    def MergeFrom(
+            self,
+            other: Union['RepeatedScalarFieldContainer[_T]', Iterable[_T]],
+    ) -> None:
+        """Appends the contents of another repeated field of the same type to this
+        one. We do not check the types of the individual fields.
+        """
+        self._values.extend(other)
+        self._message_listener.Modified()
+
+    def remove(self, elem: _T):
+        """Removes an item from the list. Similar to list.remove()."""
+        self._values.remove(elem)
+        self._message_listener.Modified()
+
+    def pop(self, key: Optional[int] = -1) -> _T:
+        """Removes and returns an item at a given index. Similar to list.pop()."""
+        value = self._values[key]
+        self.__delitem__(key)
+        return value
+
+    @overload
+    def __setitem__(self, key: int, value: _T) -> None:
+        ...
+
+    @overload
+    def __setitem__(self, key: slice, value: Iterable[_T]) -> None:
+        ...
+
+    def __setitem__(self, key, value) -> None:
+        """Sets the item on the specified position."""
+        if isinstance(key, slice):
+            if key.step is not None:
+                raise ValueError('Extended slices not supported')
+            self._values[key] = map(self._type_checker.CheckValue, value)
+            self._message_listener.Modified()
+        else:
+            self._values[key] = self._type_checker.CheckValue(value)
+            self._message_listener.Modified()
+
+    def __delitem__(self, key: Union[int, slice]) -> None:
+        """Deletes the item at the specified position."""
+        del self._values[key]
+        self._message_listener.Modified()
+
+    def __eq__(self, other: Any) -> bool:
+        """Compares the current instance with another one."""
+        if self is other:
+            return True
+        # Special case for the same type which should be common and fast.
+        if isinstance(other, self.__class__):
+            return other._values == self._values
+        # We are presumably comparing against some other sequence type.
+        return other == self._values
+
+    def __deepcopy__(
+            self,
+            unused_memo: Any = None,
+    ) -> 'RepeatedScalarFieldContainer[_T]':
+        clone = RepeatedScalarFieldContainer(
+            copy.deepcopy(self._message_listener), self._type_checker)
+        clone.MergeFrom(self)
+        return clone
+
+    def __reduce__(self, **kwargs) -> NoReturn:
+        raise pickle.PickleError(
+            "Can't pickle repeated scalar fields, convert to list first")
+
+
+# TODO(slebedev): Constrain T to be a subtype of Message.
+class RepeatedCompositeFieldContainer(BaseContainer[_T], MutableSequence[_T]):
+    """Simple, list-like container for holding repeated composite fields."""
+
+    # Disallows assignment to other attributes.
+    __slots__ = ['_message_descriptor']
+
+    def __init__(self, message_listener: Any, message_descriptor: Any) -> None:
+        """
+        Note that we pass in a descriptor instead of the generated directly,
+        since at the time we construct a _RepeatedCompositeFieldContainer we
+        haven't yet necessarily initialized the type that will be contained in the
+        container.
+
+        Args:
+          message_listener: A MessageListener implementation.
+            The RepeatedCompositeFieldContainer will call this object's
+            Modified() method when it is modified.
+          message_descriptor: A Descriptor instance describing the protocol type
+            that should be present in this container.  We'll use the
+            _concrete_class field of this descriptor when the client calls add().
+        """
+        super().__init__(message_listener)
+        self._message_descriptor = message_descriptor
+
+    def add(self, **kwargs: Any) -> _T:
+        """Adds a new element at the end of the list and returns it. Keyword
+        arguments may be used to initialize the element.
+        """
+        new_element = self._message_descriptor._concrete_class(**kwargs)
+        new_element._SetListener(self._message_listener)
+        self._values.append(new_element)
+        if not self._message_listener.dirty:
+            self._message_listener.Modified()
+        return new_element
+
+    def append(self, value: _T) -> None:
+        """Appends one element by copying the message."""
+        new_element = self._message_descriptor._concrete_class()
+        new_element._SetListener(self._message_listener)
+        new_element.CopyFrom(value)
+        self._values.append(new_element)
+        if not self._message_listener.dirty:
+            self._message_listener.Modified()
+
+    def insert(self, key: int, value: _T) -> None:
+        """Inserts the item at the specified position by copying."""
+        new_element = self._message_descriptor._concrete_class()
+        new_element._SetListener(self._message_listener)
+        new_element.CopyFrom(value)
+        self._values.insert(key, new_element)
+        if not self._message_listener.dirty:
+            self._message_listener.Modified()
+
+    def extend(self, elem_seq: Iterable[_T]) -> None:
+        """Extends by appending the given sequence of elements of the same type
+
+        as this one, copying each individual message.
+        """
+        message_class = self._message_descriptor._concrete_class
+        listener = self._message_listener
+        values = self._values
+        for message in elem_seq:
+            new_element = message_class()
+            new_element._SetListener(listener)
+            new_element.MergeFrom(message)
+            values.append(new_element)
+        listener.Modified()
+
+    def MergeFrom(
+            self,
+            other: Union['RepeatedCompositeFieldContainer[_T]', Iterable[_T]],
+    ) -> None:
+        """Appends the contents of another repeated field of the same type to this
+        one, copying each individual message.
+        """
+        self.extend(other)
+
+    def remove(self, elem: _T) -> None:
+        """Removes an item from the list. Similar to list.remove()."""
+        self._values.remove(elem)
+        self._message_listener.Modified()
+
+    def pop(self, key: Optional[int] = -1) -> _T:
+        """Removes and returns an item at a given index. Similar to list.pop()."""
+        value = self._values[key]
+        self.__delitem__(key)
+        return value
+
+    @overload
+    def __setitem__(self, key: int, value: _T) -> None:
+        ...
+
+    @overload
+    def __setitem__(self, key: slice, value: Iterable[_T]) -> None:
+        ...
+
+    def __setitem__(self, key, value):
+        # This method is implemented to make RepeatedCompositeFieldContainer
+        # structurally compatible with typing.MutableSequence. It is
+        # otherwise unsupported and will always raise an error.
+        raise TypeError(
+            f'{self.__class__.__name__} object does not support item assignment')
+
+    def __delitem__(self, key: Union[int, slice]) -> None:
+        """Deletes the item at the specified position."""
+        del self._values[key]
+        self._message_listener.Modified()
+
+    def __eq__(self, other: Any) -> bool:
+        """Compares the current instance with another one."""
+        if self is other:
+            return True
+        if not isinstance(other, self.__class__):
+            raise TypeError('Can only compare repeated composite fields against '
+                            'other repeated composite fields.')
+        return self._values == other._values
+
+
+class ScalarMap(MutableMapping[_K, _V]):
+    """Simple, type-checked, dict-like container for holding repeated scalars."""
+
+    # Disallows assignment to other attributes.
+    __slots__ = ['_key_checker', '_value_checker', '_values', '_message_listener',
+                 '_entry_descriptor']
+
+    def __init__(
+            self,
+            message_listener: Any,
+            key_checker: Any,
+            value_checker: Any,
+            entry_descriptor: Any,
+    ) -> None:
+        """
+        Args:
+          message_listener: A MessageListener implementation.
+            The ScalarMap will call this object's Modified() method when it
+            is modified.
+          key_checker: A type_checkers.ValueChecker instance to run on keys
+            inserted into this container.
+          value_checker: A type_checkers.ValueChecker instance to run on values
+            inserted into this container.
+          entry_descriptor: The MessageDescriptor of a map entry: key and value.
+        """
+        self._message_listener = message_listener
+        self._key_checker = key_checker
+        self._value_checker = value_checker
+        self._entry_descriptor = entry_descriptor
+        self._values = {}
+
+    def __getitem__(self, key: _K) -> _V:
+        try:
+            return self._values[key]
+        except KeyError:
+            key = self._key_checker.CheckValue(key)
+            val = self._value_checker.DefaultValue()
+            self._values[key] = val
+            return val
+
+    def __contains__(self, item: _K) -> bool:
+        # We check the key's type to match the strong-typing flavor of the API.
+        # Also this makes it easier to match the behavior of the C++ implementation.
+        self._key_checker.CheckValue(item)
+        return item in self._values
+
+    @overload
+    def get(self, key: _K) -> Optional[_V]:
+        ...
+
+    @overload
+    def get(self, key: _K, default: _T) -> Union[_V, _T]:
+        ...
+
+    # We need to override this explicitly, because our defaultdict-like behavior
+    # will make the default implementation (from our base class) always insert
+    # the key.
+    def get(self, key, default=None):
+        if key in self:
+            return self[key]
+        else:
+            return default
+
+    def __setitem__(self, key: _K, value: _V) -> _T:
+        checked_key = self._key_checker.CheckValue(key)
+        checked_value = self._value_checker.CheckValue(value)
+        self._values[checked_key] = checked_value
+        self._message_listener.Modified()
+
+    def __delitem__(self, key: _K) -> None:
+        del self._values[key]
+        self._message_listener.Modified()
+
+    def __len__(self) -> int:
+        return len(self._values)
+
+    def __iter__(self) -> Iterator[_K]:
+        return iter(self._values)
+
+    def __repr__(self) -> str:
+        return repr(self._values)
+
+    def MergeFrom(self, other: 'ScalarMap[_K, _V]') -> None:
+        self._values.update(other._values)
+        self._message_listener.Modified()
+
+    def InvalidateIterators(self) -> None:
+        # It appears that the only way to reliably invalidate iterators to
+        # self._values is to ensure that its size changes.
+        original = self._values
+        self._values = original.copy()
+        original[None] = None
+
+    # This is defined in the abstract base, but we can do it much more cheaply.
+    def clear(self) -> None:
+        self._values.clear()
+        self._message_listener.Modified()
+
+    def GetEntryClass(self) -> Any:
+        return self._entry_descriptor._concrete_class
+
+
+class MessageMap(MutableMapping[_K, _V]):
+    """Simple, type-checked, dict-like container for with submessage values."""
+
+    # Disallows assignment to other attributes.
+    __slots__ = ['_key_checker', '_values', '_message_listener',
+                 '_message_descriptor', '_entry_descriptor']
+
+    def __init__(
+            self,
+            message_listener: Any,
+            message_descriptor: Any,
+            key_checker: Any,
+            entry_descriptor: Any,
+    ) -> None:
+        """
+        Args:
+          message_listener: A MessageListener implementation.
+            The ScalarMap will call this object's Modified() method when it
+            is modified.
+          key_checker: A type_checkers.ValueChecker instance to run on keys
+            inserted into this container.
+          value_checker: A type_checkers.ValueChecker instance to run on values
+            inserted into this container.
+          entry_descriptor: The MessageDescriptor of a map entry: key and value.
+        """
+        self._message_listener = message_listener
+        self._message_descriptor = message_descriptor
+        self._key_checker = key_checker
+        self._entry_descriptor = entry_descriptor
+        self._values = {}
+
+    def __getitem__(self, key: _K) -> _V:
+        key = self._key_checker.CheckValue(key)
+        try:
+            return self._values[key]
+        except KeyError:
+            new_element = self._message_descriptor._concrete_class()
+            new_element._SetListener(self._message_listener)
+            self._values[key] = new_element
+            self._message_listener.Modified()
+            return new_element
+
+    def get_or_create(self, key: _K) -> _V:
+        """get_or_create() is an alias for getitem (ie. map[key]).
+
+        Args:
+          key: The key to get or create in the map.
+
+        This is useful in cases where you want to be explicit that the call is
+        mutating the map.  This can avoid lint errors for statements like this
+        that otherwise would appear to be pointless statements:
+
+          msg.my_map[key]
+        """
+        return self[key]
+
+    @overload
+    def get(self, key: _K) -> Optional[_V]:
+        ...
+
+    @overload
+    def get(self, key: _K, default: _T) -> Union[_V, _T]:
+        ...
+
+    # We need to override this explicitly, because our defaultdict-like behavior
+    # will make the default implementation (from our base class) always insert
+    # the key.
+    def get(self, key, default=None):
+        if key in self:
+            return self[key]
+        else:
+            return default
+
+    def __contains__(self, item: _K) -> bool:
+        item = self._key_checker.CheckValue(item)
+        return item in self._values
+
+    def __setitem__(self, key: _K, value: _V) -> NoReturn:
+        raise ValueError('May not set values directly, call my_map[key].foo = 5')
+
+    def __delitem__(self, key: _K) -> None:
+        key = self._key_checker.CheckValue(key)
+        del self._values[key]
+        self._message_listener.Modified()
+
+    def __len__(self) -> int:
+        return len(self._values)
+
+    def __iter__(self) -> Iterator[_K]:
+        return iter(self._values)
+
+    def __repr__(self) -> str:
+        return repr(self._values)
+
+    def MergeFrom(self, other: 'MessageMap[_K, _V]') -> None:
+        # pylint: disable=protected-access
+        for key in other._values:
+            # According to documentation: "When parsing from the wire or when merging,
+            # if there are duplicate map keys the last key seen is used".
+            if key in self:
+                del self[key]
+            self[key].CopyFrom(other[key])
+        # self._message_listener.Modified() not required here, because
+        # mutations to submessages already propagate.
+
+    def InvalidateIterators(self) -> None:
+        # It appears that the only way to reliably invalidate iterators to
+        # self._values is to ensure that its size changes.
+        original = self._values
+        self._values = original.copy()
+        original[None] = None
+
+    # This is defined in the abstract base, but we can do it much more cheaply.
+    def clear(self) -> None:
+        self._values.clear()
+        self._message_listener.Modified()
+
+    def GetEntryClass(self) -> Any:
+        return self._entry_descriptor._concrete_class
+
+
+class _UnknownField:
+    """A parsed unknown field."""
+
+    # Disallows assignment to other attributes.
+    __slots__ = ['_field_number', '_wire_type', '_data']
+
+    def __init__(self, field_number, wire_type, data):
+        self._field_number = field_number
+        self._wire_type = wire_type
+        self._data = data
+        return
+
+    def __lt__(self, other):
+        # pylint: disable=protected-access
+        return self._field_number < other._field_number
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        # pylint: disable=protected-access
+        return (self._field_number == other._field_number and
+                self._wire_type == other._wire_type and
+                self._data == other._data)
+
+
+class UnknownFieldRef:  # pylint: disable=missing-class-docstring
+
+    def __init__(self, parent, index):
+        self._parent = parent
+        self._index = index
+
+    def _check_valid(self):
+        if not self._parent:
+            raise ValueError('UnknownField does not exist. '
+                             'The parent message might be cleared.')
+        if self._index >= len(self._parent):
+            raise ValueError('UnknownField does not exist. '
+                             'The parent message might be cleared.')
+
+    @property
+    def field_number(self):
+        self._check_valid()
+        # pylint: disable=protected-access
+        return self._parent._internal_get(self._index)._field_number
+
+    @property
+    def wire_type(self):
+        self._check_valid()
+        # pylint: disable=protected-access
+        return self._parent._internal_get(self._index)._wire_type
+
+    @property
+    def data(self):
+        self._check_valid()
+        # pylint: disable=protected-access
+        return self._parent._internal_get(self._index)._data
+
+
+class UnknownFieldSet:
+    """UnknownField container"""
+
+    # Disallows assignment to other attributes.
+    __slots__ = ['_values']
+
+    def __init__(self):
+        self._values = []
+
+    def __getitem__(self, index):
+        if self._values is None:
+            raise ValueError('UnknownFields does not exist. '
+                             'The parent message might be cleared.')
+        size = len(self._values)
+        if index < 0:
+            index += size
+        if index < 0 or index >= size:
+            raise IndexError('index %d out of range'.index)
+
+        return UnknownFieldRef(self, index)
+
+    def _internal_get(self, index):
+        return self._values[index]
+
+    def __len__(self):
+        if self._values is None:
+            raise ValueError('UnknownFields does not exist. '
+                             'The parent message might be cleared.')
+        return len(self._values)
+
+    def _add(self, field_number, wire_type, data):
+        unknown_field = _UnknownField(field_number, wire_type, data)
+        self._values.append(unknown_field)
+        return unknown_field
+
+    def __iter__(self):
+        for i in range(len(self)):
+            yield UnknownFieldRef(self, i)
+
+    def _extend(self, other):
+        if other is None:
+            return
+        # pylint: disable=protected-access
+        self._values.extend(other._values)
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        # Sort unknown fields because their order shouldn't
+        # affect equality test.
+        values = list(self._values)
+        if other is None:
+            return not values
+        values.sort()
+        # pylint: disable=protected-access
+        other_values = sorted(other._values)
+        return values == other_values
+
+    def _clear(self):
+        for value in self._values:
+            # pylint: disable=protected-access
+            if isinstance(value._data, UnknownFieldSet):
+                value._data._clear()  # pylint: disable=protected-access
+        self._values = None
diff --git a/lark_channel/ws/pb/google/protobuf/internal/decoder.py b/lark_channel/ws/pb/google/protobuf/internal/decoder.py
new file mode 100644
index 0000000..a0a7c56
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/internal/decoder.py
@@ -0,0 +1,1063 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+# https://developers.google.com/protocol-buffers/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""Code for decoding protocol buffer primitives.
+
+This code is very similar to encoder.py -- read the docs for that module first.
+
+A "decoder" is a function with the signature:
+  Decode(buffer, pos, end, message, field_dict)
+The arguments are:
+  buffer:     The string containing the encoded message.
+  pos:        The current position in the string.
+  end:        The position in the string where the current message ends.  May be
+              less than len(buffer) if we're reading a sub-message.
+  message:    The message object into which we're parsing.
+  field_dict: message._fields (avoids a hashtable lookup).
+The decoder reads the field and stores it into field_dict, returning the new
+buffer position.  A decoder for a repeated field may proactively decode all of
+the elements of that field, if they appear consecutively.
+
+Note that decoders may throw any of the following:
+  IndexError:  Indicates a truncated message.
+  struct.error:  Unpacking of a fixed-width field failed.
+  message.DecodeError:  Other errors.
+
+Decoders are expected to raise an exception if they are called with pos > end.
+This allows callers to be lax about bounds checking:  it's fineto read past
+"end" as long as you are sure that someone else will notice and throw an
+exception later on.
+
+Something up the call stack is expected to catch IndexError and struct.error
+and convert them to message.DecodeError.
+
+Decoders are constructed using decoder constructors with the signature:
+  MakeDecoder(field_number, is_repeated, is_packed, key, new_default)
+The arguments are:
+  field_number:  The field number of the field we want to decode.
+  is_repeated:   Is the field a repeated field? (bool)
+  is_packed:     Is the field a packed field? (bool)
+  key:           The key to use when looking up the field within field_dict.
+                 (This is actually the FieldDescriptor but nothing in this
+                 file should depend on that.)
+  new_default:   A function which takes a message object as a parameter and
+                 returns a new instance of the default value for this field.
+                 (This is called for repeated fields and sub-messages, when an
+                 instance does not already exist.)
+
+As with encoders, we define a decoder constructor for every type of field.
+Then, for every field of every message class we construct an actual decoder.
+That decoder goes into a dict indexed by tag, so when we decode a message
+we repeatedly read a tag, look up the corresponding decoder, and invoke it.
+"""
+
+__author__ = 'kenton@google.com (Kenton Varda)'
+
+import math
+import struct
+
+from lark_channel.ws.pb.google.protobuf.internal import containers
+from lark_channel.ws.pb.google.protobuf.internal import encoder
+from lark_channel.ws.pb.google.protobuf.internal import wire_format
+from lark_channel.ws.pb.google.protobuf import message
+
+# This is not for optimization, but rather to avoid conflicts with local
+# variables named "message".
+_DecodeError = message.DecodeError
+
+
+def _VarintDecoder(mask, result_type):
+    """Return an encoder for a basic varint value (does not include tag).
+
+    Decoded values will be bitwise-anded with the given mask before being
+    returned, e.g. to limit them to 32 bits.  The returned decoder does not
+    take the usual "end" parameter -- the caller is expected to do bounds checking
+    after the fact (often the caller can defer such checking until later).  The
+    decoder returns a (value, new_pos) pair.
+    """
+
+    def DecodeVarint(buffer, pos):
+        result = 0
+        shift = 0
+        while 1:
+            b = buffer[pos]
+            result |= ((b & 0x7f) << shift)
+            pos += 1
+            if not (b & 0x80):
+                result &= mask
+                result = result_type(result)
+                return (result, pos)
+            shift += 7
+            if shift >= 64:
+                raise _DecodeError('Too many bytes when decoding varint.')
+
+    return DecodeVarint
+
+
+def _SignedVarintDecoder(bits, result_type):
+    """Like _VarintDecoder() but decodes signed values."""
+
+    signbit = 1 << (bits - 1)
+    mask = (1 << bits) - 1
+
+    def DecodeVarint(buffer, pos):
+        result = 0
+        shift = 0
+        while 1:
+            b = buffer[pos]
+            result |= ((b & 0x7f) << shift)
+            pos += 1
+            if not (b & 0x80):
+                result &= mask
+                result = (result ^ signbit) - signbit
+                result = result_type(result)
+                return (result, pos)
+            shift += 7
+            if shift >= 64:
+                raise _DecodeError('Too many bytes when decoding varint.')
+
+    return DecodeVarint
+
+
+# All 32-bit and 64-bit values are represented as int.
+_DecodeVarint = _VarintDecoder((1 << 64) - 1, int)
+_DecodeSignedVarint = _SignedVarintDecoder(64, int)
+
+# Use these versions for values which must be limited to 32 bits.
+_DecodeVarint32 = _VarintDecoder((1 << 32) - 1, int)
+_DecodeSignedVarint32 = _SignedVarintDecoder(32, int)
+
+
+def ReadTag(buffer, pos):
+    """Read a tag from the memoryview, and return a (tag_bytes, new_pos) tuple.
+
+    We return the raw bytes of the tag rather than decoding them.  The raw
+    bytes can then be used to look up the proper decoder.  This effectively allows
+    us to trade some work that would be done in pure-python (decoding a varint)
+    for work that is done in C (searching for a byte string in a hash table).
+    In a low-level language it would be much cheaper to decode the varint and
+    use that, but not in Python.
+
+    Args:
+      buffer: memoryview object of the encoded bytes
+      pos: int of the current position to start from
+
+    Returns:
+      Tuple[bytes, int] of the tag data and new position.
+    """
+    start = pos
+    while buffer[pos] & 0x80:
+        pos += 1
+    pos += 1
+
+    tag_bytes = buffer[start:pos].tobytes()
+    return tag_bytes, pos
+
+
+# --------------------------------------------------------------------
+
+
+def _SimpleDecoder(wire_type, decode_value):
+    """Return a constructor for a decoder for fields of a particular type.
+
+    Args:
+        wire_type:  The field's wire type.
+        decode_value:  A function which decodes an individual value, e.g.
+          _DecodeVarint()
+    """
+
+    def SpecificDecoder(field_number, is_repeated, is_packed, key, new_default,
+                        clear_if_default=False):
+        if is_packed:
+            local_DecodeVarint = _DecodeVarint
+
+            def DecodePackedField(buffer, pos, end, message, field_dict):
+                value = field_dict.get(key)
+                if value is None:
+                    value = field_dict.setdefault(key, new_default(message))
+                (endpoint, pos) = local_DecodeVarint(buffer, pos)
+                endpoint += pos
+                if endpoint > end:
+                    raise _DecodeError('Truncated message.')
+                while pos < endpoint:
+                    (element, pos) = decode_value(buffer, pos)
+                    value.append(element)
+                if pos > endpoint:
+                    del value[-1]  # Discard corrupt value.
+                    raise _DecodeError('Packed element was truncated.')
+                return pos
+
+            return DecodePackedField
+        elif is_repeated:
+            tag_bytes = encoder.TagBytes(field_number, wire_type)
+            tag_len = len(tag_bytes)
+
+            def DecodeRepeatedField(buffer, pos, end, message, field_dict):
+                value = field_dict.get(key)
+                if value is None:
+                    value = field_dict.setdefault(key, new_default(message))
+                while 1:
+                    (element, new_pos) = decode_value(buffer, pos)
+                    value.append(element)
+                    # Predict that the next tag is another copy of the same repeated
+                    # field.
+                    pos = new_pos + tag_len
+                    if buffer[new_pos:pos] != tag_bytes or new_pos >= end:
+                        # Prediction failed.  Return.
+                        if new_pos > end:
+                            raise _DecodeError('Truncated message.')
+                        return new_pos
+
+            return DecodeRepeatedField
+        else:
+            def DecodeField(buffer, pos, end, message, field_dict):
+                (new_value, pos) = decode_value(buffer, pos)
+                if pos > end:
+                    raise _DecodeError('Truncated message.')
+                if clear_if_default and not new_value:
+                    field_dict.pop(key, None)
+                else:
+                    field_dict[key] = new_value
+                return pos
+
+            return DecodeField
+
+    return SpecificDecoder
+
+
+def _ModifiedDecoder(wire_type, decode_value, modify_value):
+    """Like SimpleDecoder but additionally invokes modify_value on every value
+    before storing it.  Usually modify_value is ZigZagDecode.
+    """
+
+    # Reusing _SimpleDecoder is slightly slower than copying a bunch of code, but
+    # not enough to make a significant difference.
+
+    def InnerDecode(buffer, pos):
+        (result, new_pos) = decode_value(buffer, pos)
+        return (modify_value(result), new_pos)
+
+    return _SimpleDecoder(wire_type, InnerDecode)
+
+
+def _StructPackDecoder(wire_type, format):
+    """Return a constructor for a decoder for a fixed-width field.
+
+    Args:
+        wire_type:  The field's wire type.
+        format:  The format string to pass to struct.unpack().
+    """
+
+    value_size = struct.calcsize(format)
+    local_unpack = struct.unpack
+
+    # Reusing _SimpleDecoder is slightly slower than copying a bunch of code, but
+    # not enough to make a significant difference.
+
+    # Note that we expect someone up-stack to catch struct.error and convert
+    # it to _DecodeError -- this way we don't have to set up exception-
+    # handling blocks every time we parse one value.
+
+    def InnerDecode(buffer, pos):
+        new_pos = pos + value_size
+        result = local_unpack(format, buffer[pos:new_pos])[0]
+        return (result, new_pos)
+
+    return _SimpleDecoder(wire_type, InnerDecode)
+
+
+def _FloatDecoder():
+    """Returns a decoder for a float field.
+
+    This code works around a bug in struct.unpack for non-finite 32-bit
+    floating-point values.
+    """
+
+    local_unpack = struct.unpack
+
+    def InnerDecode(buffer, pos):
+        """Decode serialized float to a float and new position.
+
+        Args:
+          buffer: memoryview of the serialized bytes
+          pos: int, position in the memory view to start at.
+
+        Returns:
+          Tuple[float, int] of the deserialized float value and new position
+          in the serialized data.
+        """
+        # We expect a 32-bit value in little-endian byte order.  Bit 1 is the sign
+        # bit, bits 2-9 represent the exponent, and bits 10-32 are the significand.
+        new_pos = pos + 4
+        float_bytes = buffer[pos:new_pos].tobytes()
+
+        # If this value has all its exponent bits set, then it's non-finite.
+        # In Python 2.4, struct.unpack will convert it to a finite 64-bit value.
+        # To avoid that, we parse it specially.
+        if (float_bytes[3:4] in b'\x7F\xFF' and float_bytes[2:3] >= b'\x80'):
+            # If at least one significand bit is set...
+            if float_bytes[0:3] != b'\x00\x00\x80':
+                return (math.nan, new_pos)
+            # If sign bit is set...
+            if float_bytes[3:4] == b'\xFF':
+                return (-math.inf, new_pos)
+            return (math.inf, new_pos)
+
+        # Note that we expect someone up-stack to catch struct.error and convert
+        # it to _DecodeError -- this way we don't have to set up exception-
+        # handling blocks every time we parse one value.
+        result = local_unpack('<f', float_bytes)[0]
+        return (result, new_pos)
+
+    return _SimpleDecoder(wire_format.WIRETYPE_FIXED32, InnerDecode)
+
+
+def _DoubleDecoder():
+    """Returns a decoder for a double field.
+
+    This code works around a bug in struct.unpack for not-a-number.
+    """
+
+    local_unpack = struct.unpack
+
+    def InnerDecode(buffer, pos):
+        """Decode serialized double to a double and new position.
+
+        Args:
+          buffer: memoryview of the serialized bytes.
+          pos: int, position in the memory view to start at.
+
+        Returns:
+          Tuple[float, int] of the decoded double value and new position
+          in the serialized data.
+        """
+        # We expect a 64-bit value in little-endian byte order.  Bit 1 is the sign
+        # bit, bits 2-12 represent the exponent, and bits 13-64 are the significand.
+        new_pos = pos + 8
+        double_bytes = buffer[pos:new_pos].tobytes()
+
+        # If this value has all its exponent bits set and at least one significand
+        # bit set, it's not a number.  In Python 2.4, struct.unpack will treat it
+        # as inf or -inf.  To avoid that, we treat it specially.
+        if ((double_bytes[7:8] in b'\x7F\xFF')
+                and (double_bytes[6:7] >= b'\xF0')
+                and (double_bytes[0:7] != b'\x00\x00\x00\x00\x00\x00\xF0')):
+            return (math.nan, new_pos)
+
+        # Note that we expect someone up-stack to catch struct.error and convert
+        # it to _DecodeError -- this way we don't have to set up exception-
+        # handling blocks every time we parse one value.
+        result = local_unpack('<d', double_bytes)[0]
+        return (result, new_pos)
+
+    return _SimpleDecoder(wire_format.WIRETYPE_FIXED64, InnerDecode)
+
+
+def EnumDecoder(field_number, is_repeated, is_packed, key, new_default,
+                clear_if_default=False):
+    """Returns a decoder for enum field."""
+    enum_type = key.enum_type
+    if is_packed:
+        local_DecodeVarint = _DecodeVarint
+
+        def DecodePackedField(buffer, pos, end, message, field_dict):
+            """Decode serialized packed enum to its value and a new position.
+
+            Args:
+              buffer: memoryview of the serialized bytes.
+              pos: int, position in the memory view to start at.
+              end: int, end position of serialized data
+              message: Message object to store unknown fields in
+              field_dict: Map[Descriptor, Any] to store decoded values in.
+
+            Returns:
+              int, new position in serialized data.
+            """
+            value = field_dict.get(key)
+            if value is None:
+                value = field_dict.setdefault(key, new_default(message))
+            (endpoint, pos) = local_DecodeVarint(buffer, pos)
+            endpoint += pos
+            if endpoint > end:
+                raise _DecodeError('Truncated message.')
+            while pos < endpoint:
+                value_start_pos = pos
+                (element, pos) = _DecodeSignedVarint32(buffer, pos)
+                # pylint: disable=protected-access
+                if element in enum_type.values_by_number:
+                    value.append(element)
+                else:
+                    if not message._unknown_fields:
+                        message._unknown_fields = []
+                    tag_bytes = encoder.TagBytes(field_number,
+                                                 wire_format.WIRETYPE_VARINT)
+
+                    message._unknown_fields.append(
+                        (tag_bytes, buffer[value_start_pos:pos].tobytes()))
+                    if message._unknown_field_set is None:
+                        message._unknown_field_set = containers.UnknownFieldSet()
+                    message._unknown_field_set._add(
+                        field_number, wire_format.WIRETYPE_VARINT, element)
+                    # pylint: enable=protected-access
+            if pos > endpoint:
+                if element in enum_type.values_by_number:
+                    del value[-1]  # Discard corrupt value.
+                else:
+                    del message._unknown_fields[-1]
+                    # pylint: disable=protected-access
+                    del message._unknown_field_set._values[-1]
+                    # pylint: enable=protected-access
+                raise _DecodeError('Packed element was truncated.')
+            return pos
+
+        return DecodePackedField
+    elif is_repeated:
+        tag_bytes = encoder.TagBytes(field_number, wire_format.WIRETYPE_VARINT)
+        tag_len = len(tag_bytes)
+
+        def DecodeRepeatedField(buffer, pos, end, message, field_dict):
+            """Decode serialized repeated enum to its value and a new position.
+
+            Args:
+              buffer: memoryview of the serialized bytes.
+              pos: int, position in the memory view to start at.
+              end: int, end position of serialized data
+              message: Message object to store unknown fields in
+              field_dict: Map[Descriptor, Any] to store decoded values in.
+
+            Returns:
+              int, new position in serialized data.
+            """
+            value = field_dict.get(key)
+            if value is None:
+                value = field_dict.setdefault(key, new_default(message))
+            while 1:
+                (element, new_pos) = _DecodeSignedVarint32(buffer, pos)
+                # pylint: disable=protected-access
+                if element in enum_type.values_by_number:
+                    value.append(element)
+                else:
+                    if not message._unknown_fields:
+                        message._unknown_fields = []
+                    message._unknown_fields.append(
+                        (tag_bytes, buffer[pos:new_pos].tobytes()))
+                    if message._unknown_field_set is None:
+                        message._unknown_field_set = containers.UnknownFieldSet()
+                    message._unknown_field_set._add(
+                        field_number, wire_format.WIRETYPE_VARINT, element)
+                # pylint: enable=protected-access
+                # Predict that the next tag is another copy of the same repeated
+                # field.
+                pos = new_pos + tag_len
+                if buffer[new_pos:pos] != tag_bytes or new_pos >= end:
+                    # Prediction failed.  Return.
+                    if new_pos > end:
+                        raise _DecodeError('Truncated message.')
+                    return new_pos
+
+        return DecodeRepeatedField
+    else:
+        def DecodeField(buffer, pos, end, message, field_dict):
+            """Decode serialized repeated enum to its value and a new position.
+
+            Args:
+              buffer: memoryview of the serialized bytes.
+              pos: int, position in the memory view to start at.
+              end: int, end position of serialized data
+              message: Message object to store unknown fields in
+              field_dict: Map[Descriptor, Any] to store decoded values in.
+
+            Returns:
+              int, new position in serialized data.
+            """
+            value_start_pos = pos
+            (enum_value, pos) = _DecodeSignedVarint32(buffer, pos)
+            if pos > end:
+                raise _DecodeError('Truncated message.')
+            if clear_if_default and not enum_value:
+                field_dict.pop(key, None)
+                return pos
+            # pylint: disable=protected-access
+            if enum_value in enum_type.values_by_number:
+                field_dict[key] = enum_value
+            else:
+                if not message._unknown_fields:
+                    message._unknown_fields = []
+                tag_bytes = encoder.TagBytes(field_number,
+                                             wire_format.WIRETYPE_VARINT)
+                message._unknown_fields.append(
+                    (tag_bytes, buffer[value_start_pos:pos].tobytes()))
+                if message._unknown_field_set is None:
+                    message._unknown_field_set = containers.UnknownFieldSet()
+                message._unknown_field_set._add(
+                    field_number, wire_format.WIRETYPE_VARINT, enum_value)
+                # pylint: enable=protected-access
+            return pos
+
+        return DecodeField
+
+
+# --------------------------------------------------------------------
+
+
+Int32Decoder = _SimpleDecoder(
+    wire_format.WIRETYPE_VARINT, _DecodeSignedVarint32)
+
+Int64Decoder = _SimpleDecoder(
+    wire_format.WIRETYPE_VARINT, _DecodeSignedVarint)
+
+UInt32Decoder = _SimpleDecoder(wire_format.WIRETYPE_VARINT, _DecodeVarint32)
+UInt64Decoder = _SimpleDecoder(wire_format.WIRETYPE_VARINT, _DecodeVarint)
+
+SInt32Decoder = _ModifiedDecoder(
+    wire_format.WIRETYPE_VARINT, _DecodeVarint32, wire_format.ZigZagDecode)
+SInt64Decoder = _ModifiedDecoder(
+    wire_format.WIRETYPE_VARINT, _DecodeVarint, wire_format.ZigZagDecode)
+
+# Note that Python conveniently guarantees that when using the '<' prefix on
+# formats, they will also have the same size across all platforms (as opposed
+# to without the prefix, where their sizes depend on the C compiler's basic
+# type sizes).
+Fixed32Decoder = _StructPackDecoder(wire_format.WIRETYPE_FIXED32, '<I')
+Fixed64Decoder = _StructPackDecoder(wire_format.WIRETYPE_FIXED64, '<Q')
+SFixed32Decoder = _StructPackDecoder(wire_format.WIRETYPE_FIXED32, '<i')
+SFixed64Decoder = _StructPackDecoder(wire_format.WIRETYPE_FIXED64, '<q')
+FloatDecoder = _FloatDecoder()
+DoubleDecoder = _DoubleDecoder()
+
+BoolDecoder = _ModifiedDecoder(
+    wire_format.WIRETYPE_VARINT, _DecodeVarint, bool)
+
+
+def StringDecoder(field_number, is_repeated, is_packed, key, new_default,
+                  clear_if_default=False):
+    """Returns a decoder for a string field."""
+
+    local_DecodeVarint = _DecodeVarint
+
+    def _ConvertToUnicode(memview):
+        """Convert byte to unicode."""
+        byte_str = memview.tobytes()
+        try:
+            value = str(byte_str, 'utf-8')
+        except UnicodeDecodeError as e:
+            # add more information to the error message and re-raise it.
+            e.reason = '%s in field: %s' % (e, key.full_name)
+            raise
+
+        return value
+
+    assert not is_packed
+    if is_repeated:
+        tag_bytes = encoder.TagBytes(field_number,
+                                     wire_format.WIRETYPE_LENGTH_DELIMITED)
+        tag_len = len(tag_bytes)
+
+        def DecodeRepeatedField(buffer, pos, end, message, field_dict):
+            value = field_dict.get(key)
+            if value is None:
+                value = field_dict.setdefault(key, new_default(message))
+            while 1:
+                (size, pos) = local_DecodeVarint(buffer, pos)
+                new_pos = pos + size
+                if new_pos > end:
+                    raise _DecodeError('Truncated string.')
+                value.append(_ConvertToUnicode(buffer[pos:new_pos]))
+                # Predict that the next tag is another copy of the same repeated field.
+                pos = new_pos + tag_len
+                if buffer[new_pos:pos] != tag_bytes or new_pos == end:
+                    # Prediction failed.  Return.
+                    return new_pos
+
+        return DecodeRepeatedField
+    else:
+        def DecodeField(buffer, pos, end, message, field_dict):
+            (size, pos) = local_DecodeVarint(buffer, pos)
+            new_pos = pos + size
+            if new_pos > end:
+                raise _DecodeError('Truncated string.')
+            if clear_if_default and not size:
+                field_dict.pop(key, None)
+            else:
+                field_dict[key] = _ConvertToUnicode(buffer[pos:new_pos])
+            return new_pos
+
+        return DecodeField
+
+
+def BytesDecoder(field_number, is_repeated, is_packed, key, new_default,
+                 clear_if_default=False):
+    """Returns a decoder for a bytes field."""
+
+    local_DecodeVarint = _DecodeVarint
+
+    assert not is_packed
+    if is_repeated:
+        tag_bytes = encoder.TagBytes(field_number,
+                                     wire_format.WIRETYPE_LENGTH_DELIMITED)
+        tag_len = len(tag_bytes)
+
+        def DecodeRepeatedField(buffer, pos, end, message, field_dict):
+            value = field_dict.get(key)
+            if value is None:
+                value = field_dict.setdefault(key, new_default(message))
+            while 1:
+                (size, pos) = local_DecodeVarint(buffer, pos)
+                new_pos = pos + size
+                if new_pos > end:
+                    raise _DecodeError('Truncated string.')
+                value.append(buffer[pos:new_pos].tobytes())
+                # Predict that the next tag is another copy of the same repeated field.
+                pos = new_pos + tag_len
+                if buffer[new_pos:pos] != tag_bytes or new_pos == end:
+                    # Prediction failed.  Return.
+                    return new_pos
+
+        return DecodeRepeatedField
+    else:
+        def DecodeField(buffer, pos, end, message, field_dict):
+            (size, pos) = local_DecodeVarint(buffer, pos)
+            new_pos = pos + size
+            if new_pos > end:
+                raise _DecodeError('Truncated string.')
+            if clear_if_default and not size:
+                field_dict.pop(key, None)
+            else:
+                field_dict[key] = buffer[pos:new_pos].tobytes()
+            return new_pos
+
+        return DecodeField
+
+
+def GroupDecoder(field_number, is_repeated, is_packed, key, new_default):
+    """Returns a decoder for a group field."""
+
+    end_tag_bytes = encoder.TagBytes(field_number,
+                                     wire_format.WIRETYPE_END_GROUP)
+    end_tag_len = len(end_tag_bytes)
+
+    assert not is_packed
+    if is_repeated:
+        tag_bytes = encoder.TagBytes(field_number,
+                                     wire_format.WIRETYPE_START_GROUP)
+        tag_len = len(tag_bytes)
+
+        def DecodeRepeatedField(buffer, pos, end, message, field_dict):
+            value = field_dict.get(key)
+            if value is None:
+                value = field_dict.setdefault(key, new_default(message))
+            while 1:
+                value = field_dict.get(key)
+                if value is None:
+                    value = field_dict.setdefault(key, new_default(message))
+                # Read sub-message.
+                pos = value.add()._InternalParse(buffer, pos, end)
+                # Read end tag.
+                new_pos = pos + end_tag_len
+                if buffer[pos:new_pos] != end_tag_bytes or new_pos > end:
+                    raise _DecodeError('Missing group end tag.')
+                # Predict that the next tag is another copy of the same repeated field.
+                pos = new_pos + tag_len
+                if buffer[new_pos:pos] != tag_bytes or new_pos == end:
+                    # Prediction failed.  Return.
+                    return new_pos
+
+        return DecodeRepeatedField
+    else:
+        def DecodeField(buffer, pos, end, message, field_dict):
+            value = field_dict.get(key)
+            if value is None:
+                value = field_dict.setdefault(key, new_default(message))
+            # Read sub-message.
+            pos = value._InternalParse(buffer, pos, end)
+            # Read end tag.
+            new_pos = pos + end_tag_len
+            if buffer[pos:new_pos] != end_tag_bytes or new_pos > end:
+                raise _DecodeError('Missing group end tag.')
+            return new_pos
+
+        return DecodeField
+
+
+def MessageDecoder(field_number, is_repeated, is_packed, key, new_default):
+    """Returns a decoder for a message field."""
+
+    local_DecodeVarint = _DecodeVarint
+
+    assert not is_packed
+    if is_repeated:
+        tag_bytes = encoder.TagBytes(field_number,
+                                     wire_format.WIRETYPE_LENGTH_DELIMITED)
+        tag_len = len(tag_bytes)
+
+        def DecodeRepeatedField(buffer, pos, end, message, field_dict):
+            value = field_dict.get(key)
+            if value is None:
+                value = field_dict.setdefault(key, new_default(message))
+            while 1:
+                # Read length.
+                (size, pos) = local_DecodeVarint(buffer, pos)
+                new_pos = pos + size
+                if new_pos > end:
+                    raise _DecodeError('Truncated message.')
+                # Read sub-message.
+                if value.add()._InternalParse(buffer, pos, new_pos) != new_pos:
+                    # The only reason _InternalParse would return early is if it
+                    # encountered an end-group tag.
+                    raise _DecodeError('Unexpected end-group tag.')
+                # Predict that the next tag is another copy of the same repeated field.
+                pos = new_pos + tag_len
+                if buffer[new_pos:pos] != tag_bytes or new_pos == end:
+                    # Prediction failed.  Return.
+                    return new_pos
+
+        return DecodeRepeatedField
+    else:
+        def DecodeField(buffer, pos, end, message, field_dict):
+            value = field_dict.get(key)
+            if value is None:
+                value = field_dict.setdefault(key, new_default(message))
+            # Read length.
+            (size, pos) = local_DecodeVarint(buffer, pos)
+            new_pos = pos + size
+            if new_pos > end:
+                raise _DecodeError('Truncated message.')
+            # Read sub-message.
+            if value._InternalParse(buffer, pos, new_pos) != new_pos:
+                # The only reason _InternalParse would return early is if it encountered
+                # an end-group tag.
+                raise _DecodeError('Unexpected end-group tag.')
+            return new_pos
+
+        return DecodeField
+
+
+# --------------------------------------------------------------------
+
+MESSAGE_SET_ITEM_TAG = encoder.TagBytes(1, wire_format.WIRETYPE_START_GROUP)
+
+
+def MessageSetItemDecoder(descriptor):
+    """Returns a decoder for a MessageSet item.
+
+    The parameter is the message Descriptor.
+
+    The message set message looks like this:
+      message MessageSet {
+        repeated group Item = 1 {
+          required int32 type_id = 2;
+          required string message = 3;
+        }
+      }
+    """
+
+    type_id_tag_bytes = encoder.TagBytes(2, wire_format.WIRETYPE_VARINT)
+    message_tag_bytes = encoder.TagBytes(3, wire_format.WIRETYPE_LENGTH_DELIMITED)
+    item_end_tag_bytes = encoder.TagBytes(1, wire_format.WIRETYPE_END_GROUP)
+
+    local_ReadTag = ReadTag
+    local_DecodeVarint = _DecodeVarint
+    local_SkipField = SkipField
+
+    def DecodeItem(buffer, pos, end, message, field_dict):
+        """Decode serialized message set to its value and new position.
+
+        Args:
+          buffer: memoryview of the serialized bytes.
+          pos: int, position in the memory view to start at.
+          end: int, end position of serialized data
+          message: Message object to store unknown fields in
+          field_dict: Map[Descriptor, Any] to store decoded values in.
+
+        Returns:
+          int, new position in serialized data.
+        """
+        message_set_item_start = pos
+        type_id = -1
+        message_start = -1
+        message_end = -1
+
+        # Technically, type_id and message can appear in any order, so we need
+        # a little loop here.
+        while 1:
+            (tag_bytes, pos) = local_ReadTag(buffer, pos)
+            if tag_bytes == type_id_tag_bytes:
+                (type_id, pos) = local_DecodeVarint(buffer, pos)
+            elif tag_bytes == message_tag_bytes:
+                (size, message_start) = local_DecodeVarint(buffer, pos)
+                pos = message_end = message_start + size
+            elif tag_bytes == item_end_tag_bytes:
+                break
+            else:
+                pos = SkipField(buffer, pos, end, tag_bytes)
+                if pos == -1:
+                    raise _DecodeError('Missing group end tag.')
+
+        if pos > end:
+            raise _DecodeError('Truncated message.')
+
+        if type_id == -1:
+            raise _DecodeError('MessageSet item missing type_id.')
+        if message_start == -1:
+            raise _DecodeError('MessageSet item missing message.')
+
+        extension = message.Extensions._FindExtensionByNumber(type_id)
+        # pylint: disable=protected-access
+        if extension is not None:
+            value = field_dict.get(extension)
+            if value is None:
+                message_type = extension.message_type
+                if not hasattr(message_type, '_concrete_class'):
+                    # pylint: disable=protected-access
+                    message._FACTORY.GetPrototype(message_type)
+                value = field_dict.setdefault(
+                    extension, message_type._concrete_class())
+            if value._InternalParse(buffer, message_start, message_end) != message_end:
+                # The only reason _InternalParse would return early is if it encountered
+                # an end-group tag.
+                raise _DecodeError('Unexpected end-group tag.')
+        else:
+            if not message._unknown_fields:
+                message._unknown_fields = []
+            message._unknown_fields.append(
+                (MESSAGE_SET_ITEM_TAG, buffer[message_set_item_start:pos].tobytes()))
+            if message._unknown_field_set is None:
+                message._unknown_field_set = containers.UnknownFieldSet()
+            message._unknown_field_set._add(
+                type_id,
+                wire_format.WIRETYPE_LENGTH_DELIMITED,
+                buffer[message_start:message_end].tobytes())
+            # pylint: enable=protected-access
+
+        return pos
+
+    return DecodeItem
+
+
+# --------------------------------------------------------------------
+
+def MapDecoder(field_descriptor, new_default, is_message_map):
+    """Returns a decoder for a map field."""
+
+    key = field_descriptor
+    tag_bytes = encoder.TagBytes(field_descriptor.number,
+                                 wire_format.WIRETYPE_LENGTH_DELIMITED)
+    tag_len = len(tag_bytes)
+    local_DecodeVarint = _DecodeVarint
+    # Can't read _concrete_class yet; might not be initialized.
+    message_type = field_descriptor.message_type
+
+    def DecodeMap(buffer, pos, end, message, field_dict):
+        submsg = message_type._concrete_class()
+        value = field_dict.get(key)
+        if value is None:
+            value = field_dict.setdefault(key, new_default(message))
+        while 1:
+            # Read length.
+            (size, pos) = local_DecodeVarint(buffer, pos)
+            new_pos = pos + size
+            if new_pos > end:
+                raise _DecodeError('Truncated message.')
+            # Read sub-message.
+            submsg.Clear()
+            if submsg._InternalParse(buffer, pos, new_pos) != new_pos:
+                # The only reason _InternalParse would return early is if it
+                # encountered an end-group tag.
+                raise _DecodeError('Unexpected end-group tag.')
+
+            if is_message_map:
+                value[submsg.key].CopyFrom(submsg.value)
+            else:
+                value[submsg.key] = submsg.value
+
+            # Predict that the next tag is another copy of the same repeated field.
+            pos = new_pos + tag_len
+            if buffer[new_pos:pos] != tag_bytes or new_pos == end:
+                # Prediction failed.  Return.
+                return new_pos
+
+    return DecodeMap
+
+
+# --------------------------------------------------------------------
+# Optimization is not as heavy here because calls to SkipField() are rare,
+# except for handling end-group tags.
+
+def _SkipVarint(buffer, pos, end):
+    """Skip a varint value.  Returns the new position."""
+    # Previously ord(buffer[pos]) raised IndexError when pos is out of range.
+    # With this code, ord(b'') raises TypeError.  Both are handled in
+    # python_message.py to generate a 'Truncated message' error.
+    while ord(buffer[pos:pos + 1].tobytes()) & 0x80:
+        pos += 1
+    pos += 1
+    if pos > end:
+        raise _DecodeError('Truncated message.')
+    return pos
+
+
+def _SkipFixed64(buffer, pos, end):
+    """Skip a fixed64 value.  Returns the new position."""
+
+    pos += 8
+    if pos > end:
+        raise _DecodeError('Truncated message.')
+    return pos
+
+
+def _DecodeFixed64(buffer, pos):
+    """Decode a fixed64."""
+    new_pos = pos + 8
+    return (struct.unpack('<Q', buffer[pos:new_pos])[0], new_pos)
+
+
+def _SkipLengthDelimited(buffer, pos, end):
+    """Skip a length-delimited value.  Returns the new position."""
+
+    (size, pos) = _DecodeVarint(buffer, pos)
+    pos += size
+    if pos > end:
+        raise _DecodeError('Truncated message.')
+    return pos
+
+
+def _SkipGroup(buffer, pos, end):
+    """Skip sub-group.  Returns the new position."""
+
+    while 1:
+        (tag_bytes, pos) = ReadTag(buffer, pos)
+        new_pos = SkipField(buffer, pos, end, tag_bytes)
+        if new_pos == -1:
+            return pos
+        pos = new_pos
+
+
+def _DecodeUnknownFieldSet(buffer, pos, end_pos=None):
+    """Decode UnknownFieldSet.  Returns the UnknownFieldSet and new position."""
+
+    unknown_field_set = containers.UnknownFieldSet()
+    while end_pos is None or pos < end_pos:
+        (tag_bytes, pos) = ReadTag(buffer, pos)
+        (tag, _) = _DecodeVarint(tag_bytes, 0)
+        field_number, wire_type = wire_format.UnpackTag(tag)
+        if wire_type == wire_format.WIRETYPE_END_GROUP:
+            break
+        (data, pos) = _DecodeUnknownField(buffer, pos, wire_type)
+        # pylint: disable=protected-access
+        unknown_field_set._add(field_number, wire_type, data)
+
+    return (unknown_field_set, pos)
+
+
+def _DecodeUnknownField(buffer, pos, wire_type):
+    """Decode a unknown field.  Returns the UnknownField and new position."""
+
+    if wire_type == wire_format.WIRETYPE_VARINT:
+        (data, pos) = _DecodeVarint(buffer, pos)
+    elif wire_type == wire_format.WIRETYPE_FIXED64:
+        (data, pos) = _DecodeFixed64(buffer, pos)
+    elif wire_type == wire_format.WIRETYPE_FIXED32:
+        (data, pos) = _DecodeFixed32(buffer, pos)
+    elif wire_type == wire_format.WIRETYPE_LENGTH_DELIMITED:
+        (size, pos) = _DecodeVarint(buffer, pos)
+        data = buffer[pos:pos + size].tobytes()
+        pos += size
+    elif wire_type == wire_format.WIRETYPE_START_GROUP:
+        (data, pos) = _DecodeUnknownFieldSet(buffer, pos)
+    elif wire_type == wire_format.WIRETYPE_END_GROUP:
+        return (0, -1)
+    else:
+        raise _DecodeError('Wrong wire type in tag.')
+
+    return (data, pos)
+
+
+def _EndGroup(buffer, pos, end):
+    """Skipping an END_GROUP tag returns -1 to tell the parent loop to break."""
+
+    return -1
+
+
+def _SkipFixed32(buffer, pos, end):
+    """Skip a fixed32 value.  Returns the new position."""
+
+    pos += 4
+    if pos > end:
+        raise _DecodeError('Truncated message.')
+    return pos
+
+
+def _DecodeFixed32(buffer, pos):
+    """Decode a fixed32."""
+
+    new_pos = pos + 4
+    return (struct.unpack('<I', buffer[pos:new_pos])[0], new_pos)
+
+
+def _RaiseInvalidWireType(buffer, pos, end):
+    """Skip function for unknown wire types.  Raises an exception."""
+
+    raise _DecodeError('Tag had invalid wire type.')
+
+
+def _FieldSkipper():
+    """Constructs the SkipField function."""
+
+    WIRETYPE_TO_SKIPPER = [
+        _SkipVarint,
+        _SkipFixed64,
+        _SkipLengthDelimited,
+        _SkipGroup,
+        _EndGroup,
+        _SkipFixed32,
+        _RaiseInvalidWireType,
+        _RaiseInvalidWireType,
+    ]
+
+    wiretype_mask = wire_format.TAG_TYPE_MASK
+
+    def SkipField(buffer, pos, end, tag_bytes):
+        """Skips a field with the specified tag.
+
+        |pos| should point to the byte immediately after the tag.
+
+        Returns:
+            The new position (after the tag value), or -1 if the tag is an end-group
+            tag (in which case the calling loop should break).
+        """
+
+        # The wire type is always in the first byte since varints are little-endian.
+        wire_type = ord(tag_bytes[0:1]) & wiretype_mask
+        return WIRETYPE_TO_SKIPPER[wire_type](buffer, pos, end)
+
+    return SkipField
+
+
+SkipField = _FieldSkipper()
diff --git a/lark_channel/ws/pb/google/protobuf/internal/encoder.py b/lark_channel/ws/pb/google/protobuf/internal/encoder.py
new file mode 100644
index 0000000..ee94862
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/internal/encoder.py
@@ -0,0 +1,890 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+# https://developers.google.com/protocol-buffers/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""Code for encoding protocol message primitives.
+
+Contains the logic for encoding every logical protocol field type
+into one of the 5 physical wire types.
+
+This code is designed to push the Python interpreter's performance to the
+limits.
+
+The basic idea is that at startup time, for every field (i.e. every
+FieldDescriptor) we construct two functions:  a "sizer" and an "encoder".  The
+sizer takes a value of this field's type and computes its byte size.  The
+encoder takes a writer function and a value.  It encodes the value into byte
+strings and invokes the writer function to write those strings.  Typically the
+writer function is the write() method of a BytesIO.
+
+We try to do as much work as possible when constructing the writer and the
+sizer rather than when calling them.  In particular:
+* We copy any needed global functions to local variables, so that we do not need
+  to do costly global table lookups at runtime.
+* Similarly, we try to do any attribute lookups at startup time if possible.
+* Every field's tag is encoded to bytes at startup, since it can't change at
+  runtime.
+* Whatever component of the field size we can compute at startup, we do.
+* We *avoid* sharing code if doing so would make the code slower and not sharing
+  does not burden us too much.  For example, encoders for repeated fields do
+  not just call the encoders for singular fields in a loop because this would
+  add an extra function call overhead for every loop iteration; instead, we
+  manually inline the single-value encoder into the loop.
+* If a Python function lacks a return statement, Python actually generates
+  instructions to pop the result of the last statement off the stack, push
+  None onto the stack, and then return that.  If we really don't care what
+  value is returned, then we can save two instructions by returning the
+  result of the last statement.  It looks funny but it helps.
+* We assume that type and bounds checking has happened at a higher level.
+"""
+
+__author__ = 'kenton@google.com (Kenton Varda)'
+
+import struct
+
+from lark_channel.ws.pb.google.protobuf.internal import wire_format
+
+# This will overflow and thus become IEEE-754 "infinity".  We would use
+# "float('inf')" but it doesn't work on Windows pre-Python-2.6.
+_POS_INF = 1e10000
+_NEG_INF = -_POS_INF
+
+
+def _VarintSize(value):
+    """Compute the size of a varint value."""
+    if value <= 0x7f: return 1
+    if value <= 0x3fff: return 2
+    if value <= 0x1fffff: return 3
+    if value <= 0xfffffff: return 4
+    if value <= 0x7ffffffff: return 5
+    if value <= 0x3ffffffffff: return 6
+    if value <= 0x1ffffffffffff: return 7
+    if value <= 0xffffffffffffff: return 8
+    if value <= 0x7fffffffffffffff: return 9
+    return 10
+
+
+def _SignedVarintSize(value):
+    """Compute the size of a signed varint value."""
+    if value < 0: return 10
+    if value <= 0x7f: return 1
+    if value <= 0x3fff: return 2
+    if value <= 0x1fffff: return 3
+    if value <= 0xfffffff: return 4
+    if value <= 0x7ffffffff: return 5
+    if value <= 0x3ffffffffff: return 6
+    if value <= 0x1ffffffffffff: return 7
+    if value <= 0xffffffffffffff: return 8
+    if value <= 0x7fffffffffffffff: return 9
+    return 10
+
+
+def _TagSize(field_number):
+    """Returns the number of bytes required to serialize a tag with this field
+    number."""
+    # Just pass in type 0, since the type won't affect the tag+type size.
+    return _VarintSize(wire_format.PackTag(field_number, 0))
+
+
+# --------------------------------------------------------------------
+# In this section we define some generic sizers.  Each of these functions
+# takes parameters specific to a particular field type, e.g. int32 or fixed64.
+# It returns another function which in turn takes parameters specific to a
+# particular field, e.g. the field number and whether it is repeated or packed.
+# Look at the next section to see how these are used.
+
+
+def _SimpleSizer(compute_value_size):
+    """A sizer which uses the function compute_value_size to compute the size of
+    each value.  Typically compute_value_size is _VarintSize."""
+
+    def SpecificSizer(field_number, is_repeated, is_packed):
+        tag_size = _TagSize(field_number)
+        if is_packed:
+            local_VarintSize = _VarintSize
+
+            def PackedFieldSize(value):
+                result = 0
+                for element in value:
+                    result += compute_value_size(element)
+                return result + local_VarintSize(result) + tag_size
+
+            return PackedFieldSize
+        elif is_repeated:
+            def RepeatedFieldSize(value):
+                result = tag_size * len(value)
+                for element in value:
+                    result += compute_value_size(element)
+                return result
+
+            return RepeatedFieldSize
+        else:
+            def FieldSize(value):
+                return tag_size + compute_value_size(value)
+
+            return FieldSize
+
+    return SpecificSizer
+
+
+def _ModifiedSizer(compute_value_size, modify_value):
+    """Like SimpleSizer, but modify_value is invoked on each value before it is
+    passed to compute_value_size.  modify_value is typically ZigZagEncode."""
+
+    def SpecificSizer(field_number, is_repeated, is_packed):
+        tag_size = _TagSize(field_number)
+        if is_packed:
+            local_VarintSize = _VarintSize
+
+            def PackedFieldSize(value):
+                result = 0
+                for element in value:
+                    result += compute_value_size(modify_value(element))
+                return result + local_VarintSize(result) + tag_size
+
+            return PackedFieldSize
+        elif is_repeated:
+            def RepeatedFieldSize(value):
+                result = tag_size * len(value)
+                for element in value:
+                    result += compute_value_size(modify_value(element))
+                return result
+
+            return RepeatedFieldSize
+        else:
+            def FieldSize(value):
+                return tag_size + compute_value_size(modify_value(value))
+
+            return FieldSize
+
+    return SpecificSizer
+
+
+def _FixedSizer(value_size):
+    """Like _SimpleSizer except for a fixed-size field.  The input is the size
+    of one value."""
+
+    def SpecificSizer(field_number, is_repeated, is_packed):
+        tag_size = _TagSize(field_number)
+        if is_packed:
+            local_VarintSize = _VarintSize
+
+            def PackedFieldSize(value):
+                result = len(value) * value_size
+                return result + local_VarintSize(result) + tag_size
+
+            return PackedFieldSize
+        elif is_repeated:
+            element_size = value_size + tag_size
+
+            def RepeatedFieldSize(value):
+                return len(value) * element_size
+
+            return RepeatedFieldSize
+        else:
+            field_size = value_size + tag_size
+
+            def FieldSize(value):
+                return field_size
+
+            return FieldSize
+
+    return SpecificSizer
+
+
+# ====================================================================
+# Here we declare a sizer constructor for each field type.  Each "sizer
+# constructor" is a function that takes (field_number, is_repeated, is_packed)
+# as parameters and returns a sizer, which in turn takes a field value as
+# a parameter and returns its encoded size.
+
+
+Int32Sizer = Int64Sizer = EnumSizer = _SimpleSizer(_SignedVarintSize)
+
+UInt32Sizer = UInt64Sizer = _SimpleSizer(_VarintSize)
+
+SInt32Sizer = SInt64Sizer = _ModifiedSizer(
+    _SignedVarintSize, wire_format.ZigZagEncode)
+
+Fixed32Sizer = SFixed32Sizer = FloatSizer = _FixedSizer(4)
+Fixed64Sizer = SFixed64Sizer = DoubleSizer = _FixedSizer(8)
+
+BoolSizer = _FixedSizer(1)
+
+
+def StringSizer(field_number, is_repeated, is_packed):
+    """Returns a sizer for a string field."""
+
+    tag_size = _TagSize(field_number)
+    local_VarintSize = _VarintSize
+    local_len = len
+    assert not is_packed
+    if is_repeated:
+        def RepeatedFieldSize(value):
+            result = tag_size * len(value)
+            for element in value:
+                l = local_len(element.encode('utf-8'))
+                result += local_VarintSize(l) + l
+            return result
+
+        return RepeatedFieldSize
+    else:
+        def FieldSize(value):
+            l = local_len(value.encode('utf-8'))
+            return tag_size + local_VarintSize(l) + l
+
+        return FieldSize
+
+
+def BytesSizer(field_number, is_repeated, is_packed):
+    """Returns a sizer for a bytes field."""
+
+    tag_size = _TagSize(field_number)
+    local_VarintSize = _VarintSize
+    local_len = len
+    assert not is_packed
+    if is_repeated:
+        def RepeatedFieldSize(value):
+            result = tag_size * len(value)
+            for element in value:
+                l = local_len(element)
+                result += local_VarintSize(l) + l
+            return result
+
+        return RepeatedFieldSize
+    else:
+        def FieldSize(value):
+            l = local_len(value)
+            return tag_size + local_VarintSize(l) + l
+
+        return FieldSize
+
+
+def GroupSizer(field_number, is_repeated, is_packed):
+    """Returns a sizer for a group field."""
+
+    tag_size = _TagSize(field_number) * 2
+    assert not is_packed
+    if is_repeated:
+        def RepeatedFieldSize(value):
+            result = tag_size * len(value)
+            for element in value:
+                result += element.ByteSize()
+            return result
+
+        return RepeatedFieldSize
+    else:
+        def FieldSize(value):
+            return tag_size + value.ByteSize()
+
+        return FieldSize
+
+
+def MessageSizer(field_number, is_repeated, is_packed):
+    """Returns a sizer for a message field."""
+
+    tag_size = _TagSize(field_number)
+    local_VarintSize = _VarintSize
+    assert not is_packed
+    if is_repeated:
+        def RepeatedFieldSize(value):
+            result = tag_size * len(value)
+            for element in value:
+                l = element.ByteSize()
+                result += local_VarintSize(l) + l
+            return result
+
+        return RepeatedFieldSize
+    else:
+        def FieldSize(value):
+            l = value.ByteSize()
+            return tag_size + local_VarintSize(l) + l
+
+        return FieldSize
+
+
+# --------------------------------------------------------------------
+# MessageSet is special: it needs custom logic to compute its size properly.
+
+
+def MessageSetItemSizer(field_number):
+    """Returns a sizer for extensions of MessageSet.
+
+    The message set message looks like this:
+      message MessageSet {
+        repeated group Item = 1 {
+          required int32 type_id = 2;
+          required string message = 3;
+        }
+      }
+    """
+    static_size = (_TagSize(1) * 2 + _TagSize(2) + _VarintSize(field_number) +
+                   _TagSize(3))
+    local_VarintSize = _VarintSize
+
+    def FieldSize(value):
+        l = value.ByteSize()
+        return static_size + local_VarintSize(l) + l
+
+    return FieldSize
+
+
+# --------------------------------------------------------------------
+# Map is special: it needs custom logic to compute its size properly.
+
+
+def MapSizer(field_descriptor, is_message_map):
+    """Returns a sizer for a map field."""
+
+    # Can't look at field_descriptor.message_type._concrete_class because it may
+    # not have been initialized yet.
+    message_type = field_descriptor.message_type
+    message_sizer = MessageSizer(field_descriptor.number, False, False)
+
+    def FieldSize(map_value):
+        total = 0
+        for key in map_value:
+            value = map_value[key]
+            # It's wasteful to create the messages and throw them away one second
+            # later since we'll do the same for the actual encode.  But there's not an
+            # obvious way to avoid this within the current design without tons of code
+            # duplication. For message map, value.ByteSize() should be called to
+            # update the status.
+            entry_msg = message_type._concrete_class(key=key, value=value)
+            total += message_sizer(entry_msg)
+            if is_message_map:
+                value.ByteSize()
+        return total
+
+    return FieldSize
+
+
+# ====================================================================
+# Encoders!
+
+
+def _VarintEncoder():
+    """Return an encoder for a basic varint value (does not include tag)."""
+
+    local_int2byte = struct.Struct('>B').pack
+
+    def EncodeVarint(write, value, unused_deterministic=None):
+        bits = value & 0x7f
+        value >>= 7
+        while value:
+            write(local_int2byte(0x80 | bits))
+            bits = value & 0x7f
+            value >>= 7
+        return write(local_int2byte(bits))
+
+    return EncodeVarint
+
+
+def _SignedVarintEncoder():
+    """Return an encoder for a basic signed varint value (does not include
+    tag)."""
+
+    local_int2byte = struct.Struct('>B').pack
+
+    def EncodeSignedVarint(write, value, unused_deterministic=None):
+        if value < 0:
+            value += (1 << 64)
+        bits = value & 0x7f
+        value >>= 7
+        while value:
+            write(local_int2byte(0x80 | bits))
+            bits = value & 0x7f
+            value >>= 7
+        return write(local_int2byte(bits))
+
+    return EncodeSignedVarint
+
+
+_EncodeVarint = _VarintEncoder()
+_EncodeSignedVarint = _SignedVarintEncoder()
+
+
+def _VarintBytes(value):
+    """Encode the given integer as a varint and return the bytes.  This is only
+    called at startup time so it doesn't need to be fast."""
+
+    pieces = []
+    _EncodeVarint(pieces.append, value, True)
+    return b"".join(pieces)
+
+
+def TagBytes(field_number, wire_type):
+    """Encode the given tag and return the bytes.  Only called at startup."""
+
+    return bytes(_VarintBytes(wire_format.PackTag(field_number, wire_type)))
+
+
+# --------------------------------------------------------------------
+# As with sizers (see above), we have a number of common encoder
+# implementations.
+
+
+def _SimpleEncoder(wire_type, encode_value, compute_value_size):
+    """Return a constructor for an encoder for fields of a particular type.
+
+    Args:
+        wire_type:  The field's wire type, for encoding tags.
+        encode_value:  A function which encodes an individual value, e.g.
+          _EncodeVarint().
+        compute_value_size:  A function which computes the size of an individual
+          value, e.g. _VarintSize().
+    """
+
+    def SpecificEncoder(field_number, is_repeated, is_packed):
+        if is_packed:
+            tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED)
+            local_EncodeVarint = _EncodeVarint
+
+            def EncodePackedField(write, value, deterministic):
+                write(tag_bytes)
+                size = 0
+                for element in value:
+                    size += compute_value_size(element)
+                local_EncodeVarint(write, size, deterministic)
+                for element in value:
+                    encode_value(write, element, deterministic)
+
+            return EncodePackedField
+        elif is_repeated:
+            tag_bytes = TagBytes(field_number, wire_type)
+
+            def EncodeRepeatedField(write, value, deterministic):
+                for element in value:
+                    write(tag_bytes)
+                    encode_value(write, element, deterministic)
+
+            return EncodeRepeatedField
+        else:
+            tag_bytes = TagBytes(field_number, wire_type)
+
+            def EncodeField(write, value, deterministic):
+                write(tag_bytes)
+                return encode_value(write, value, deterministic)
+
+            return EncodeField
+
+    return SpecificEncoder
+
+
+def _ModifiedEncoder(wire_type, encode_value, compute_value_size, modify_value):
+    """Like SimpleEncoder but additionally invokes modify_value on every value
+    before passing it to encode_value.  Usually modify_value is ZigZagEncode."""
+
+    def SpecificEncoder(field_number, is_repeated, is_packed):
+        if is_packed:
+            tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED)
+            local_EncodeVarint = _EncodeVarint
+
+            def EncodePackedField(write, value, deterministic):
+                write(tag_bytes)
+                size = 0
+                for element in value:
+                    size += compute_value_size(modify_value(element))
+                local_EncodeVarint(write, size, deterministic)
+                for element in value:
+                    encode_value(write, modify_value(element), deterministic)
+
+            return EncodePackedField
+        elif is_repeated:
+            tag_bytes = TagBytes(field_number, wire_type)
+
+            def EncodeRepeatedField(write, value, deterministic):
+                for element in value:
+                    write(tag_bytes)
+                    encode_value(write, modify_value(element), deterministic)
+
+            return EncodeRepeatedField
+        else:
+            tag_bytes = TagBytes(field_number, wire_type)
+
+            def EncodeField(write, value, deterministic):
+                write(tag_bytes)
+                return encode_value(write, modify_value(value), deterministic)
+
+            return EncodeField
+
+    return SpecificEncoder
+
+
+def _StructPackEncoder(wire_type, format):
+    """Return a constructor for an encoder for a fixed-width field.
+
+    Args:
+        wire_type:  The field's wire type, for encoding tags.
+        format:  The format string to pass to struct.pack().
+    """
+
+    value_size = struct.calcsize(format)
+
+    def SpecificEncoder(field_number, is_repeated, is_packed):
+        local_struct_pack = struct.pack
+        if is_packed:
+            tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED)
+            local_EncodeVarint = _EncodeVarint
+
+            def EncodePackedField(write, value, deterministic):
+                write(tag_bytes)
+                local_EncodeVarint(write, len(value) * value_size, deterministic)
+                for element in value:
+                    write(local_struct_pack(format, element))
+
+            return EncodePackedField
+        elif is_repeated:
+            tag_bytes = TagBytes(field_number, wire_type)
+
+            def EncodeRepeatedField(write, value, unused_deterministic=None):
+                for element in value:
+                    write(tag_bytes)
+                    write(local_struct_pack(format, element))
+
+            return EncodeRepeatedField
+        else:
+            tag_bytes = TagBytes(field_number, wire_type)
+
+            def EncodeField(write, value, unused_deterministic=None):
+                write(tag_bytes)
+                return write(local_struct_pack(format, value))
+
+            return EncodeField
+
+    return SpecificEncoder
+
+
+def _FloatingPointEncoder(wire_type, format):
+    """Return a constructor for an encoder for float fields.
+
+    This is like StructPackEncoder, but catches errors that may be due to
+    passing non-finite floating-point values to struct.pack, and makes a
+    second attempt to encode those values.
+
+    Args:
+        wire_type:  The field's wire type, for encoding tags.
+        format:  The format string to pass to struct.pack().
+    """
+
+    value_size = struct.calcsize(format)
+    if value_size == 4:
+        def EncodeNonFiniteOrRaise(write, value):
+            # Remember that the serialized form uses little-endian byte order.
+            if value == _POS_INF:
+                write(b'\x00\x00\x80\x7F')
+            elif value == _NEG_INF:
+                write(b'\x00\x00\x80\xFF')
+            elif value != value:  # NaN
+                write(b'\x00\x00\xC0\x7F')
+            else:
+                raise
+    elif value_size == 8:
+        def EncodeNonFiniteOrRaise(write, value):
+            if value == _POS_INF:
+                write(b'\x00\x00\x00\x00\x00\x00\xF0\x7F')
+            elif value == _NEG_INF:
+                write(b'\x00\x00\x00\x00\x00\x00\xF0\xFF')
+            elif value != value:  # NaN
+                write(b'\x00\x00\x00\x00\x00\x00\xF8\x7F')
+            else:
+                raise
+    else:
+        raise ValueError('Can\'t encode floating-point values that are '
+                         '%d bytes long (only 4 or 8)' % value_size)
+
+    def SpecificEncoder(field_number, is_repeated, is_packed):
+        local_struct_pack = struct.pack
+        if is_packed:
+            tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED)
+            local_EncodeVarint = _EncodeVarint
+
+            def EncodePackedField(write, value, deterministic):
+                write(tag_bytes)
+                local_EncodeVarint(write, len(value) * value_size, deterministic)
+                for element in value:
+                    # This try/except block is going to be faster than any code that
+                    # we could write to check whether element is finite.
+                    try:
+                        write(local_struct_pack(format, element))
+                    except SystemError:
+                        EncodeNonFiniteOrRaise(write, element)
+
+            return EncodePackedField
+        elif is_repeated:
+            tag_bytes = TagBytes(field_number, wire_type)
+
+            def EncodeRepeatedField(write, value, unused_deterministic=None):
+                for element in value:
+                    write(tag_bytes)
+                    try:
+                        write(local_struct_pack(format, element))
+                    except SystemError:
+                        EncodeNonFiniteOrRaise(write, element)
+
+            return EncodeRepeatedField
+        else:
+            tag_bytes = TagBytes(field_number, wire_type)
+
+            def EncodeField(write, value, unused_deterministic=None):
+                write(tag_bytes)
+                try:
+                    write(local_struct_pack(format, value))
+                except SystemError:
+                    EncodeNonFiniteOrRaise(write, value)
+
+            return EncodeField
+
+    return SpecificEncoder
+
+
+# ====================================================================
+# Here we declare an encoder constructor for each field type.  These work
+# very similarly to sizer constructors, described earlier.
+
+
+Int32Encoder = Int64Encoder = EnumEncoder = _SimpleEncoder(
+    wire_format.WIRETYPE_VARINT, _EncodeSignedVarint, _SignedVarintSize)
+
+UInt32Encoder = UInt64Encoder = _SimpleEncoder(
+    wire_format.WIRETYPE_VARINT, _EncodeVarint, _VarintSize)
+
+SInt32Encoder = SInt64Encoder = _ModifiedEncoder(
+    wire_format.WIRETYPE_VARINT, _EncodeVarint, _VarintSize,
+    wire_format.ZigZagEncode)
+
+# Note that Python conveniently guarantees that when using the '<' prefix on
+# formats, they will also have the same size across all platforms (as opposed
+# to without the prefix, where their sizes depend on the C compiler's basic
+# type sizes).
+Fixed32Encoder = _StructPackEncoder(wire_format.WIRETYPE_FIXED32, '<I')
+Fixed64Encoder = _StructPackEncoder(wire_format.WIRETYPE_FIXED64, '<Q')
+SFixed32Encoder = _StructPackEncoder(wire_format.WIRETYPE_FIXED32, '<i')
+SFixed64Encoder = _StructPackEncoder(wire_format.WIRETYPE_FIXED64, '<q')
+FloatEncoder = _FloatingPointEncoder(wire_format.WIRETYPE_FIXED32, '<f')
+DoubleEncoder = _FloatingPointEncoder(wire_format.WIRETYPE_FIXED64, '<d')
+
+
+def BoolEncoder(field_number, is_repeated, is_packed):
+    """Returns an encoder for a boolean field."""
+
+    false_byte = b'\x00'
+    true_byte = b'\x01'
+    if is_packed:
+        tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED)
+        local_EncodeVarint = _EncodeVarint
+
+        def EncodePackedField(write, value, deterministic):
+            write(tag_bytes)
+            local_EncodeVarint(write, len(value), deterministic)
+            for element in value:
+                if element:
+                    write(true_byte)
+                else:
+                    write(false_byte)
+
+        return EncodePackedField
+    elif is_repeated:
+        tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_VARINT)
+
+        def EncodeRepeatedField(write, value, unused_deterministic=None):
+            for element in value:
+                write(tag_bytes)
+                if element:
+                    write(true_byte)
+                else:
+                    write(false_byte)
+
+        return EncodeRepeatedField
+    else:
+        tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_VARINT)
+
+        def EncodeField(write, value, unused_deterministic=None):
+            write(tag_bytes)
+            if value:
+                return write(true_byte)
+            return write(false_byte)
+
+        return EncodeField
+
+
+def StringEncoder(field_number, is_repeated, is_packed):
+    """Returns an encoder for a string field."""
+
+    tag = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED)
+    local_EncodeVarint = _EncodeVarint
+    local_len = len
+    assert not is_packed
+    if is_repeated:
+        def EncodeRepeatedField(write, value, deterministic):
+            for element in value:
+                encoded = element.encode('utf-8')
+                write(tag)
+                local_EncodeVarint(write, local_len(encoded), deterministic)
+                write(encoded)
+
+        return EncodeRepeatedField
+    else:
+        def EncodeField(write, value, deterministic):
+            encoded = value.encode('utf-8')
+            write(tag)
+            local_EncodeVarint(write, local_len(encoded), deterministic)
+            return write(encoded)
+
+        return EncodeField
+
+
+def BytesEncoder(field_number, is_repeated, is_packed):
+    """Returns an encoder for a bytes field."""
+
+    tag = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED)
+    local_EncodeVarint = _EncodeVarint
+    local_len = len
+    assert not is_packed
+    if is_repeated:
+        def EncodeRepeatedField(write, value, deterministic):
+            for element in value:
+                write(tag)
+                local_EncodeVarint(write, local_len(element), deterministic)
+                write(element)
+
+        return EncodeRepeatedField
+    else:
+        def EncodeField(write, value, deterministic):
+            write(tag)
+            local_EncodeVarint(write, local_len(value), deterministic)
+            return write(value)
+
+        return EncodeField
+
+
+def GroupEncoder(field_number, is_repeated, is_packed):
+    """Returns an encoder for a group field."""
+
+    start_tag = TagBytes(field_number, wire_format.WIRETYPE_START_GROUP)
+    end_tag = TagBytes(field_number, wire_format.WIRETYPE_END_GROUP)
+    assert not is_packed
+    if is_repeated:
+        def EncodeRepeatedField(write, value, deterministic):
+            for element in value:
+                write(start_tag)
+                element._InternalSerialize(write, deterministic)
+                write(end_tag)
+
+        return EncodeRepeatedField
+    else:
+        def EncodeField(write, value, deterministic):
+            write(start_tag)
+            value._InternalSerialize(write, deterministic)
+            return write(end_tag)
+
+        return EncodeField
+
+
+def MessageEncoder(field_number, is_repeated, is_packed):
+    """Returns an encoder for a message field."""
+
+    tag = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED)
+    local_EncodeVarint = _EncodeVarint
+    assert not is_packed
+    if is_repeated:
+        def EncodeRepeatedField(write, value, deterministic):
+            for element in value:
+                write(tag)
+                local_EncodeVarint(write, element.ByteSize(), deterministic)
+                element._InternalSerialize(write, deterministic)
+
+        return EncodeRepeatedField
+    else:
+        def EncodeField(write, value, deterministic):
+            write(tag)
+            local_EncodeVarint(write, value.ByteSize(), deterministic)
+            return value._InternalSerialize(write, deterministic)
+
+        return EncodeField
+
+
+# --------------------------------------------------------------------
+# As before, MessageSet is special.
+
+
+def MessageSetItemEncoder(field_number):
+    """Encoder for extensions of MessageSet.
+
+    The message set message looks like this:
+      message MessageSet {
+        repeated group Item = 1 {
+          required int32 type_id = 2;
+          required string message = 3;
+        }
+      }
+    """
+    start_bytes = b"".join([
+        TagBytes(1, wire_format.WIRETYPE_START_GROUP),
+        TagBytes(2, wire_format.WIRETYPE_VARINT),
+        _VarintBytes(field_number),
+        TagBytes(3, wire_format.WIRETYPE_LENGTH_DELIMITED)])
+    end_bytes = TagBytes(1, wire_format.WIRETYPE_END_GROUP)
+    local_EncodeVarint = _EncodeVarint
+
+    def EncodeField(write, value, deterministic):
+        write(start_bytes)
+        local_EncodeVarint(write, value.ByteSize(), deterministic)
+        value._InternalSerialize(write, deterministic)
+        return write(end_bytes)
+
+    return EncodeField
+
+
+# --------------------------------------------------------------------
+# As before, Map is special.
+
+
+def MapEncoder(field_descriptor):
+    """Encoder for extensions of MessageSet.
+
+    Maps always have a wire format like this:
+      message MapEntry {
+        key_type key = 1;
+        value_type value = 2;
+      }
+      repeated MapEntry map = N;
+    """
+    # Can't look at field_descriptor.message_type._concrete_class because it may
+    # not have been initialized yet.
+    message_type = field_descriptor.message_type
+    encode_message = MessageEncoder(field_descriptor.number, False, False)
+
+    def EncodeField(write, value, deterministic):
+        value_keys = sorted(value.keys()) if deterministic else value
+        for key in value_keys:
+            entry_msg = message_type._concrete_class(key=key, value=value[key])
+            encode_message(write, entry_msg, deterministic)
+
+    return EncodeField
diff --git a/lark_channel/ws/pb/google/protobuf/internal/enum_type_wrapper.py b/lark_channel/ws/pb/google/protobuf/internal/enum_type_wrapper.py
new file mode 100644
index 0000000..d7a261f
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/internal/enum_type_wrapper.py
@@ -0,0 +1,124 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+# https://developers.google.com/protocol-buffers/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""A simple wrapper around enum types to expose utility functions.
+
+Instances are created as properties with the same name as the enum they wrap
+on proto classes.  For usage, see:
+  reflection_test.py
+"""
+
+__author__ = 'rabsatt@google.com (Kevin Rabsatt)'
+
+
+class EnumTypeWrapper(object):
+    """A utility for finding the names of enum values."""
+
+    DESCRIPTOR = None
+
+    # This is a type alias, which mypy typing stubs can type as
+    # a genericized parameter constrained to an int, allowing subclasses
+    # to be typed with more constraint in .pyi stubs
+    # Eg.
+    # def MyGeneratedEnum(Message):
+    #   ValueType = NewType('ValueType', int)
+    #   def Name(self, number: MyGeneratedEnum.ValueType) -> str
+    ValueType = int
+
+    def __init__(self, enum_type):
+        """Inits EnumTypeWrapper with an EnumDescriptor."""
+        self._enum_type = enum_type
+        self.DESCRIPTOR = enum_type  # pylint: disable=invalid-name
+
+    def Name(self, number):  # pylint: disable=invalid-name
+        """Returns a string containing the name of an enum value."""
+        try:
+            return self._enum_type.values_by_number[number].name
+        except KeyError:
+            pass  # fall out to break exception chaining
+
+        if not isinstance(number, int):
+            raise TypeError(
+                'Enum value for {} must be an int, but got {} {!r}.'.format(
+                    self._enum_type.name, type(number), number))
+        else:
+            # repr here to handle the odd case when you pass in a boolean.
+            raise ValueError('Enum {} has no name defined for value {!r}'.format(
+                self._enum_type.name, number))
+
+    def Value(self, name):  # pylint: disable=invalid-name
+        """Returns the value corresponding to the given enum name."""
+        try:
+            return self._enum_type.values_by_name[name].number
+        except KeyError:
+            pass  # fall out to break exception chaining
+        raise ValueError('Enum {} has no value defined for name {!r}'.format(
+            self._enum_type.name, name))
+
+    def keys(self):
+        """Return a list of the string names in the enum.
+
+        Returns:
+          A list of strs, in the order they were defined in the .proto file.
+        """
+
+        return [value_descriptor.name
+                for value_descriptor in self._enum_type.values]
+
+    def values(self):
+        """Return a list of the integer values in the enum.
+
+        Returns:
+          A list of ints, in the order they were defined in the .proto file.
+        """
+
+        return [value_descriptor.number
+                for value_descriptor in self._enum_type.values]
+
+    def items(self):
+        """Return a list of the (name, value) pairs of the enum.
+
+        Returns:
+          A list of (str, int) pairs, in the order they were defined
+          in the .proto file.
+        """
+        return [(value_descriptor.name, value_descriptor.number)
+                for value_descriptor in self._enum_type.values]
+
+    def __getattr__(self, name):
+        """Returns the value corresponding to the given enum name."""
+        try:
+            return super(
+                EnumTypeWrapper,
+                self).__getattribute__('_enum_type').values_by_name[name].number
+        except KeyError:
+            pass  # fall out to break exception chaining
+        raise AttributeError('Enum {} has no value defined for name {!r}'.format(
+            self._enum_type.name, name))
diff --git a/lark_channel/ws/pb/google/protobuf/internal/extension_dict.py b/lark_channel/ws/pb/google/protobuf/internal/extension_dict.py
new file mode 100644
index 0000000..a3e7e7d
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/internal/extension_dict.py
@@ -0,0 +1,212 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+# https://developers.google.com/protocol-buffers/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""Contains _ExtensionDict class to represent extensions.
+"""
+
+from lark_channel.ws.pb.google.protobuf.internal import type_checkers
+from lark_channel.ws.pb.google.protobuf.descriptor import FieldDescriptor
+
+
+def _VerifyExtensionHandle(message, extension_handle):
+    """Verify that the given extension handle is valid."""
+
+    if not isinstance(extension_handle, FieldDescriptor):
+        raise KeyError('HasExtension() expects an extension handle, got: %s' %
+                       extension_handle)
+
+    if not extension_handle.is_extension:
+        raise KeyError('"%s" is not an extension.' % extension_handle.full_name)
+
+    if not extension_handle.containing_type:
+        raise KeyError('"%s" is missing a containing_type.'
+                       % extension_handle.full_name)
+
+    if extension_handle.containing_type is not message.DESCRIPTOR:
+        raise KeyError('Extension "%s" extends message type "%s", but this '
+                       'message is of type "%s".' %
+                       (extension_handle.full_name,
+                        extension_handle.containing_type.full_name,
+                        message.DESCRIPTOR.full_name))
+
+
+# TODO(robinson): Unify error handling of "unknown extension" crap.
+# TODO(robinson): Support iteritems()-style iteration over all
+# extensions with the "has" bits turned on?
+class _ExtensionDict(object):
+    """Dict-like container for Extension fields on proto instances.
+
+    Note that in all cases we expect extension handles to be
+    FieldDescriptors.
+    """
+
+    def __init__(self, extended_message):
+        """
+        Args:
+          extended_message: Message instance for which we are the Extensions dict.
+        """
+        self._extended_message = extended_message
+
+    def __getitem__(self, extension_handle):
+        """Returns the current value of the given extension handle."""
+
+        _VerifyExtensionHandle(self._extended_message, extension_handle)
+
+        result = self._extended_message._fields.get(extension_handle)
+        if result is not None:
+            return result
+
+        if extension_handle.label == FieldDescriptor.LABEL_REPEATED:
+            result = extension_handle._default_constructor(self._extended_message)
+        elif extension_handle.cpp_type == FieldDescriptor.CPPTYPE_MESSAGE:
+            message_type = extension_handle.message_type
+            if not hasattr(message_type, '_concrete_class'):
+                # pylint: disable=protected-access
+                self._extended_message._FACTORY.GetPrototype(message_type)
+            assert getattr(extension_handle.message_type, '_concrete_class', None), (
+                    'Uninitialized concrete class found for field %r (message type %r)'
+                    % (extension_handle.full_name,
+                       extension_handle.message_type.full_name))
+            result = extension_handle.message_type._concrete_class()
+            try:
+                result._SetListener(self._extended_message._listener_for_children)
+            except ReferenceError:
+                pass
+        else:
+            # Singular scalar -- just return the default without inserting into the
+            # dict.
+            return extension_handle.default_value
+
+        # Atomically check if another thread has preempted us and, if not, swap
+        # in the new object we just created.  If someone has preempted us, we
+        # take that object and discard ours.
+        # WARNING:  We are relying on setdefault() being atomic.  This is true
+        #   in CPython but we haven't investigated others.  This warning appears
+        #   in several other locations in this file.
+        result = self._extended_message._fields.setdefault(
+            extension_handle, result)
+
+        return result
+
+    def __eq__(self, other):
+        if not isinstance(other, self.__class__):
+            return False
+
+        my_fields = self._extended_message.ListFields()
+        other_fields = other._extended_message.ListFields()
+
+        # Get rid of non-extension fields.
+        my_fields = [field for field in my_fields if field.is_extension]
+        other_fields = [field for field in other_fields if field.is_extension]
+
+        return my_fields == other_fields
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __len__(self):
+        fields = self._extended_message.ListFields()
+        # Get rid of non-extension fields.
+        extension_fields = [field for field in fields if field[0].is_extension]
+        return len(extension_fields)
+
+    def __hash__(self):
+        raise TypeError('unhashable object')
+
+    # Note that this is only meaningful for non-repeated, scalar extension
+    # fields.  Note also that we may have to call _Modified() when we do
+    # successfully set a field this way, to set any necessary "has" bits in the
+    # ancestors of the extended message.
+    def __setitem__(self, extension_handle, value):
+        """If extension_handle specifies a non-repeated, scalar extension
+        field, sets the value of that field.
+        """
+
+        _VerifyExtensionHandle(self._extended_message, extension_handle)
+
+        if (extension_handle.label == FieldDescriptor.LABEL_REPEATED or
+                extension_handle.cpp_type == FieldDescriptor.CPPTYPE_MESSAGE):
+            raise TypeError(
+                'Cannot assign to extension "%s" because it is a repeated or '
+                'composite type.' % extension_handle.full_name)
+
+        # It's slightly wasteful to lookup the type checker each time,
+        # but we expect this to be a vanishingly uncommon case anyway.
+        type_checker = type_checkers.GetTypeChecker(extension_handle)
+        # pylint: disable=protected-access
+        self._extended_message._fields[extension_handle] = (
+            type_checker.CheckValue(value))
+        self._extended_message._Modified()
+
+    def __delitem__(self, extension_handle):
+        self._extended_message.ClearExtension(extension_handle)
+
+    def _FindExtensionByName(self, name):
+        """Tries to find a known extension with the specified name.
+
+        Args:
+          name: Extension full name.
+
+        Returns:
+          Extension field descriptor.
+        """
+        return self._extended_message._extensions_by_name.get(name, None)
+
+    def _FindExtensionByNumber(self, number):
+        """Tries to find a known extension with the field number.
+
+        Args:
+          number: Extension field number.
+
+        Returns:
+          Extension field descriptor.
+        """
+        return self._extended_message._extensions_by_number.get(number, None)
+
+    def __iter__(self):
+        # Return a generator over the populated extension fields
+        return (f[0] for f in self._extended_message.ListFields()
+                if f[0].is_extension)
+
+    def __contains__(self, extension_handle):
+        _VerifyExtensionHandle(self._extended_message, extension_handle)
+
+        if extension_handle not in self._extended_message._fields:
+            return False
+
+        if extension_handle.label == FieldDescriptor.LABEL_REPEATED:
+            return bool(self._extended_message._fields.get(extension_handle))
+
+        if extension_handle.cpp_type == FieldDescriptor.CPPTYPE_MESSAGE:
+            value = self._extended_message._fields.get(extension_handle)
+            # pylint: disable=protected-access
+            return value is not None and value._is_present_in_parent
+
+        return True
diff --git a/lark_channel/ws/pb/google/protobuf/internal/message_listener.py b/lark_channel/ws/pb/google/protobuf/internal/message_listener.py
new file mode 100644
index 0000000..1955988
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/internal/message_listener.py
@@ -0,0 +1,76 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+# https://developers.google.com/protocol-buffers/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""Defines a listener interface for observing certain
+state transitions on Message objects.
+
+Also defines a null implementation of this interface.
+"""
+
+__author__ = 'robinson@google.com (Will Robinson)'
+
+
+class MessageListener(object):
+    """Listens for modifications made to a message.  Meant to be registered via
+    Message._SetListener().
+
+    Attributes:
+      dirty:  If True, then calling Modified() would be a no-op.  This can be
+              used to avoid these calls entirely in the common case.
+    """
+
+    def Modified(self):
+        """Called every time the message is modified in such a way that the parent
+        message may need to be updated.  This currently means either:
+        (a) The message was modified for the first time, so the parent message
+            should henceforth mark the message as present.
+        (b) The message's cached byte size became dirty -- i.e. the message was
+            modified for the first time after a previous call to ByteSize().
+            Therefore the parent should also mark its byte size as dirty.
+        Note that (a) implies (b), since new objects start out with a client cached
+        size (zero).  However, we document (a) explicitly because it is important.
+
+        Modified() will *only* be called in response to one of these two events --
+        not every time the sub-message is modified.
+
+        Note that if the listener's |dirty| attribute is true, then calling
+        Modified at the moment would be a no-op, so it can be skipped.  Performance-
+        sensitive callers should check this attribute directly before calling since
+        it will be true most of the time.
+        """
+
+        raise NotImplementedError
+
+
+class NullMessageListener(object):
+    """No-op MessageListener implementation."""
+
+    def Modified(self):
+        pass
diff --git a/lark_channel/ws/pb/google/protobuf/internal/python_message.py b/lark_channel/ws/pb/google/protobuf/internal/python_message.py
new file mode 100644
index 0000000..61e5ebe
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/internal/python_message.py
@@ -0,0 +1,1575 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+# https://developers.google.com/protocol-buffers/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# This code is meant to work on Python 2.4 and above only.
+#
+# TODO(robinson): Helpers for verbose, common checks like seeing if a
+# descriptor's cpp_type is CPPTYPE_MESSAGE.
+
+"""Contains a metaclass and helper functions used to create
+protocol message classes from Descriptor objects at runtime.
+
+Recall that a metaclass is the "type" of a class.
+(A class is to a metaclass what an instance is to a class.)
+
+In this case, we use the GeneratedProtocolMessageType metaclass
+to inject all the useful functionality into the classes
+output by the protocol compiler at compile-time.
+
+The upshot of all this is that the real implementation
+details for ALL pure-Python protocol buffers are *here in
+this file*.
+"""
+
+__author__ = 'robinson@google.com (Will Robinson)'
+
+from io import BytesIO
+import struct
+import sys
+import weakref
+
+# We use "as" to avoid name collisions with variables.
+from lark_channel.ws.pb.google.protobuf.internal import api_implementation
+from lark_channel.ws.pb.google.protobuf.internal import containers
+from lark_channel.ws.pb.google.protobuf.internal import decoder
+from lark_channel.ws.pb.google.protobuf.internal import encoder
+from lark_channel.ws.pb.google.protobuf.internal import enum_type_wrapper
+from lark_channel.ws.pb.google.protobuf.internal import extension_dict
+from lark_channel.ws.pb.google.protobuf.internal import message_listener as message_listener_mod
+from lark_channel.ws.pb.google.protobuf.internal import type_checkers
+from lark_channel.ws.pb.google.protobuf.internal import well_known_types
+from lark_channel.ws.pb.google.protobuf.internal import wire_format
+from lark_channel.ws.pb.google.protobuf import descriptor as descriptor_mod
+from lark_channel.ws.pb.google.protobuf import message as message_mod
+from lark_channel.ws.pb.google.protobuf import text_format
+
+_FieldDescriptor = descriptor_mod.FieldDescriptor
+_AnyFullTypeName = 'google.protobuf.Any'
+_ExtensionDict = extension_dict._ExtensionDict
+
+
+class GeneratedProtocolMessageType(type):
+    """Metaclass for protocol message classes created at runtime from Descriptors.
+
+    We add implementations for all methods described in the Message class.  We
+    also create properties to allow getting/setting all fields in the protocol
+    message.  Finally, we create slots to prevent users from accidentally
+    "setting" nonexistent fields in the protocol message, which then wouldn't get
+    serialized / deserialized properly.
+
+    The protocol compiler currently uses this metaclass to create protocol
+    message classes at runtime.  Clients can also manually create their own
+    classes at runtime, as in this example:
+
+    mydescriptor = Descriptor(.....)
+    factory = symbol_database.Default()
+    factory.pool.AddDescriptor(mydescriptor)
+    MyProtoClass = factory.GetPrototype(mydescriptor)
+    myproto_instance = MyProtoClass()
+    myproto.foo_field = 23
+    ...
+    """
+
+    # Must be consistent with the protocol-compiler code in
+    # proto2/compiler/internal/generator.*.
+    _DESCRIPTOR_KEY = 'DESCRIPTOR'
+
+    def __new__(cls, name, bases, dictionary):
+        """Custom allocation for runtime-generated class types.
+
+        We override __new__ because this is apparently the only place
+        where we can meaningfully set __slots__ on the class we're creating(?).
+        (The interplay between metaclasses and slots is not very well-documented).
+
+        Args:
+          name: Name of the class (ignored, but required by the
+            metaclass protocol).
+          bases: Base classes of the class we're constructing.
+            (Should be message.Message).  We ignore this field, but
+            it's required by the metaclass protocol
+          dictionary: The class dictionary of the class we're
+            constructing.  dictionary[_DESCRIPTOR_KEY] must contain
+            a Descriptor object describing this protocol message
+            type.
+
+        Returns:
+          Newly-allocated class.
+
+        Raises:
+          RuntimeError: Generated code only work with python cpp extension.
+        """
+        descriptor = dictionary[GeneratedProtocolMessageType._DESCRIPTOR_KEY]
+
+        if isinstance(descriptor, str):
+            raise RuntimeError('The generated code only work with python cpp '
+                               'extension, but it is using pure python runtime.')
+
+        # If a concrete class already exists for this descriptor, don't try to
+        # create another.  Doing so will break any messages that already exist with
+        # the existing class.
+        #
+        # The C++ implementation appears to have its own internal `PyMessageFactory`
+        # to achieve similar results.
+        #
+        # This most commonly happens in `text_format.py` when using descriptors from
+        # a custom pool; it calls symbol_database.Global().getPrototype() on a
+        # descriptor which already has an existing concrete class.
+        new_class = getattr(descriptor, '_concrete_class', None)
+        if new_class:
+            return new_class
+
+        if descriptor.full_name in well_known_types.WKTBASES:
+            bases += (well_known_types.WKTBASES[descriptor.full_name],)
+        _AddClassAttributesForNestedExtensions(descriptor, dictionary)
+        _AddSlots(descriptor, dictionary)
+
+        superclass = super(GeneratedProtocolMessageType, cls)
+        new_class = superclass.__new__(cls, name, bases, dictionary)
+        return new_class
+
+    def __init__(cls, name, bases, dictionary):
+        """Here we perform the majority of our work on the class.
+        We add enum getters, an __init__ method, implementations
+        of all Message methods, and properties for all fields
+        in the protocol type.
+
+        Args:
+          name: Name of the class (ignored, but required by the
+            metaclass protocol).
+          bases: Base classes of the class we're constructing.
+            (Should be message.Message).  We ignore this field, but
+            it's required by the metaclass protocol
+          dictionary: The class dictionary of the class we're
+            constructing.  dictionary[_DESCRIPTOR_KEY] must contain
+            a Descriptor object describing this protocol message
+            type.
+        """
+        descriptor = dictionary[GeneratedProtocolMessageType._DESCRIPTOR_KEY]
+
+        # If this is an _existing_ class looked up via `_concrete_class` in the
+        # __new__ method above, then we don't need to re-initialize anything.
+        existing_class = getattr(descriptor, '_concrete_class', None)
+        if existing_class:
+            assert existing_class is cls, (
+                    'Duplicate `GeneratedProtocolMessageType` created for descriptor %r'
+                    % (descriptor.full_name))
+            return
+
+        cls._decoders_by_tag = {}
+        if (descriptor.has_options and
+                descriptor.GetOptions().message_set_wire_format):
+            cls._decoders_by_tag[decoder.MESSAGE_SET_ITEM_TAG] = (
+                decoder.MessageSetItemDecoder(descriptor), None)
+
+        # Attach stuff to each FieldDescriptor for quick lookup later on.
+        for field in descriptor.fields:
+            _AttachFieldHelpers(cls, field)
+
+        descriptor._concrete_class = cls  # pylint: disable=protected-access
+        _AddEnumValues(descriptor, cls)
+        _AddInitMethod(descriptor, cls)
+        _AddPropertiesForFields(descriptor, cls)
+        _AddPropertiesForExtensions(descriptor, cls)
+        _AddStaticMethods(cls)
+        _AddMessageMethods(descriptor, cls)
+        _AddPrivateHelperMethods(descriptor, cls)
+
+        superclass = super(GeneratedProtocolMessageType, cls)
+        superclass.__init__(name, bases, dictionary)
+
+
+# Stateless helpers for GeneratedProtocolMessageType below.
+# Outside clients should not access these directly.
+#
+# I opted not to make any of these methods on the metaclass, to make it more
+# clear that I'm not really using any state there and to keep clients from
+# thinking that they have direct access to these construction helpers.
+
+
+def _PropertyName(proto_field_name):
+    """Returns the name of the public property attribute which
+    clients can use to get and (in some cases) set the value
+    of a protocol message field.
+
+    Args:
+      proto_field_name: The protocol message field name, exactly
+        as it appears (or would appear) in a .proto file.
+    """
+    # TODO(robinson): Escape Python keywords (e.g., yield), and test this support.
+    # nnorwitz makes my day by writing:
+    # """
+    # FYI.  See the keyword module in the stdlib. This could be as simple as:
+    #
+    # if keyword.iskeyword(proto_field_name):
+    #   return proto_field_name + "_"
+    # return proto_field_name
+    # """
+    # Kenton says:  The above is a BAD IDEA.  People rely on being able to use
+    #   getattr() and setattr() to reflectively manipulate field values.  If we
+    #   rename the properties, then every such user has to also make sure to apply
+    #   the same transformation.  Note that currently if you name a field "yield",
+    #   you can still access it just fine using getattr/setattr -- it's not even
+    #   that cumbersome to do so.
+    # TODO(kenton):  Remove this method entirely if/when everyone agrees with my
+    #   position.
+    return proto_field_name
+
+
+def _AddSlots(message_descriptor, dictionary):
+    """Adds a __slots__ entry to dictionary, containing the names of all valid
+    attributes for this message type.
+
+    Args:
+      message_descriptor: A Descriptor instance describing this message type.
+      dictionary: Class dictionary to which we'll add a '__slots__' entry.
+    """
+    dictionary['__slots__'] = ['_cached_byte_size',
+                               '_cached_byte_size_dirty',
+                               '_fields',
+                               '_unknown_fields',
+                               '_unknown_field_set',
+                               '_is_present_in_parent',
+                               '_listener',
+                               '_listener_for_children',
+                               '__weakref__',
+                               '_oneofs']
+
+
+def _IsMessageSetExtension(field):
+    return (field.is_extension and
+            field.containing_type.has_options and
+            field.containing_type.GetOptions().message_set_wire_format and
+            field.type == _FieldDescriptor.TYPE_MESSAGE and
+            field.label == _FieldDescriptor.LABEL_OPTIONAL)
+
+
+def _IsMapField(field):
+    return (field.type == _FieldDescriptor.TYPE_MESSAGE and
+            field.message_type.has_options and
+            field.message_type.GetOptions().map_entry)
+
+
+def _IsMessageMapField(field):
+    value_type = field.message_type.fields_by_name['value']
+    return value_type.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE
+
+
+def _AttachFieldHelpers(cls, field_descriptor):
+    is_repeated = (field_descriptor.label == _FieldDescriptor.LABEL_REPEATED)
+    is_packable = (is_repeated and
+                   wire_format.IsTypePackable(field_descriptor.type))
+    is_proto3 = field_descriptor.containing_type.syntax == 'proto3'
+    if not is_packable:
+        is_packed = False
+    elif field_descriptor.containing_type.syntax == 'proto2':
+        is_packed = (field_descriptor.has_options and
+                     field_descriptor.GetOptions().packed)
+    else:
+        has_packed_false = (field_descriptor.has_options and
+                            field_descriptor.GetOptions().HasField('packed') and
+                            field_descriptor.GetOptions().packed == False)
+        is_packed = not has_packed_false
+    is_map_entry = _IsMapField(field_descriptor)
+
+    if is_map_entry:
+        field_encoder = encoder.MapEncoder(field_descriptor)
+        sizer = encoder.MapSizer(field_descriptor,
+                                 _IsMessageMapField(field_descriptor))
+    elif _IsMessageSetExtension(field_descriptor):
+        field_encoder = encoder.MessageSetItemEncoder(field_descriptor.number)
+        sizer = encoder.MessageSetItemSizer(field_descriptor.number)
+    else:
+        field_encoder = type_checkers.TYPE_TO_ENCODER[field_descriptor.type](
+            field_descriptor.number, is_repeated, is_packed)
+        sizer = type_checkers.TYPE_TO_SIZER[field_descriptor.type](
+            field_descriptor.number, is_repeated, is_packed)
+
+    field_descriptor._encoder = field_encoder
+    field_descriptor._sizer = sizer
+    field_descriptor._default_constructor = _DefaultValueConstructorForField(
+        field_descriptor)
+
+    def AddDecoder(wiretype, is_packed):
+        tag_bytes = encoder.TagBytes(field_descriptor.number, wiretype)
+        decode_type = field_descriptor.type
+        if (decode_type == _FieldDescriptor.TYPE_ENUM and
+                type_checkers.SupportsOpenEnums(field_descriptor)):
+            decode_type = _FieldDescriptor.TYPE_INT32
+
+        oneof_descriptor = None
+        clear_if_default = False
+        if field_descriptor.containing_oneof is not None:
+            oneof_descriptor = field_descriptor
+        elif (is_proto3 and not is_repeated and
+              field_descriptor.cpp_type != _FieldDescriptor.CPPTYPE_MESSAGE):
+            clear_if_default = True
+
+        if is_map_entry:
+            is_message_map = _IsMessageMapField(field_descriptor)
+
+            field_decoder = decoder.MapDecoder(
+                field_descriptor, _GetInitializeDefaultForMap(field_descriptor),
+                is_message_map)
+        elif decode_type == _FieldDescriptor.TYPE_STRING:
+            field_decoder = decoder.StringDecoder(
+                field_descriptor.number, is_repeated, is_packed,
+                field_descriptor, field_descriptor._default_constructor,
+                clear_if_default)
+        elif field_descriptor.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:
+            field_decoder = type_checkers.TYPE_TO_DECODER[decode_type](
+                field_descriptor.number, is_repeated, is_packed,
+                field_descriptor, field_descriptor._default_constructor)
+        else:
+            field_decoder = type_checkers.TYPE_TO_DECODER[decode_type](
+                field_descriptor.number, is_repeated, is_packed,
+                # pylint: disable=protected-access
+                field_descriptor, field_descriptor._default_constructor,
+                clear_if_default)
+
+        cls._decoders_by_tag[tag_bytes] = (field_decoder, oneof_descriptor)
+
+    AddDecoder(type_checkers.FIELD_TYPE_TO_WIRE_TYPE[field_descriptor.type],
+               False)
+
+    if is_repeated and wire_format.IsTypePackable(field_descriptor.type):
+        # To support wire compatibility of adding packed = true, add a decoder for
+        # packed values regardless of the field's options.
+        AddDecoder(wire_format.WIRETYPE_LENGTH_DELIMITED, True)
+
+
+def _AddClassAttributesForNestedExtensions(descriptor, dictionary):
+    extensions = descriptor.extensions_by_name
+    for extension_name, extension_field in extensions.items():
+        assert extension_name not in dictionary
+        dictionary[extension_name] = extension_field
+
+
+def _AddEnumValues(descriptor, cls):
+    """Sets class-level attributes for all enum fields defined in this message.
+
+    Also exporting a class-level object that can name enum values.
+
+    Args:
+      descriptor: Descriptor object for this message type.
+      cls: Class we're constructing for this message type.
+    """
+    for enum_type in descriptor.enum_types:
+        setattr(cls, enum_type.name, enum_type_wrapper.EnumTypeWrapper(enum_type))
+        for enum_value in enum_type.values:
+            setattr(cls, enum_value.name, enum_value.number)
+
+
+def _GetInitializeDefaultForMap(field):
+    if field.label != _FieldDescriptor.LABEL_REPEATED:
+        raise ValueError('map_entry set on non-repeated field %s' % (
+            field.name))
+    fields_by_name = field.message_type.fields_by_name
+    key_checker = type_checkers.GetTypeChecker(fields_by_name['key'])
+
+    value_field = fields_by_name['value']
+    if _IsMessageMapField(field):
+        def MakeMessageMapDefault(message):
+            return containers.MessageMap(
+                message._listener_for_children, value_field.message_type, key_checker,
+                field.message_type)
+
+        return MakeMessageMapDefault
+    else:
+        value_checker = type_checkers.GetTypeChecker(value_field)
+
+        def MakePrimitiveMapDefault(message):
+            return containers.ScalarMap(
+                message._listener_for_children, key_checker, value_checker,
+                field.message_type)
+
+        return MakePrimitiveMapDefault
+
+
+def _DefaultValueConstructorForField(field):
+    """Returns a function which returns a default value for a field.
+
+    Args:
+      field: FieldDescriptor object for this field.
+
+    The returned function has one argument:
+      message: Message instance containing this field, or a weakref proxy
+        of same.
+
+    That function in turn returns a default value for this field.  The default
+      value may refer back to |message| via a weak reference.
+    """
+
+    if _IsMapField(field):
+        return _GetInitializeDefaultForMap(field)
+
+    if field.label == _FieldDescriptor.LABEL_REPEATED:
+        if field.has_default_value and field.default_value != []:
+            raise ValueError('Repeated field default value not empty list: %s' % (
+                field.default_value))
+        if field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:
+            # We can't look at _concrete_class yet since it might not have
+            # been set.  (Depends on order in which we initialize the classes).
+            message_type = field.message_type
+
+            def MakeRepeatedMessageDefault(message):
+                return containers.RepeatedCompositeFieldContainer(
+                    message._listener_for_children, field.message_type)
+
+            return MakeRepeatedMessageDefault
+        else:
+            type_checker = type_checkers.GetTypeChecker(field)
+
+            def MakeRepeatedScalarDefault(message):
+                return containers.RepeatedScalarFieldContainer(
+                    message._listener_for_children, type_checker)
+
+            return MakeRepeatedScalarDefault
+
+    if field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:
+        # _concrete_class may not yet be initialized.
+        message_type = field.message_type
+
+        def MakeSubMessageDefault(message):
+            assert getattr(message_type, '_concrete_class', None), (
+                    'Uninitialized concrete class found for field %r (message type %r)'
+                    % (field.full_name, message_type.full_name))
+            result = message_type._concrete_class()
+            result._SetListener(
+                _OneofListener(message, field)
+                if field.containing_oneof is not None
+                else message._listener_for_children)
+            return result
+
+        return MakeSubMessageDefault
+
+    def MakeScalarDefault(message):
+        # TODO(protobuf-team): This may be broken since there may not be
+        # default_value.  Combine with has_default_value somehow.
+        return field.default_value
+
+    return MakeScalarDefault
+
+
+def _ReraiseTypeErrorWithFieldName(message_name, field_name):
+    """Re-raise the currently-handled TypeError with the field name added."""
+    exc = sys.exc_info()[1]
+    if len(exc.args) == 1 and type(exc) is TypeError:
+        # simple TypeError; add field name to exception message
+        exc = TypeError('%s for field %s.%s' % (str(exc), message_name, field_name))
+
+    # re-raise possibly-amended exception with original traceback:
+    raise exc.with_traceback(sys.exc_info()[2])
+
+
+def _AddInitMethod(message_descriptor, cls):
+    """Adds an __init__ method to cls."""
+
+    def _GetIntegerEnumValue(enum_type, value):
+        """Convert a string or integer enum value to an integer.
+
+        If the value is a string, it is converted to the enum value in
+        enum_type with the same name.  If the value is not a string, it's
+        returned as-is.  (No conversion or bounds-checking is done.)
+        """
+        if isinstance(value, str):
+            try:
+                return enum_type.values_by_name[value].number
+            except KeyError:
+                raise ValueError('Enum type %s: unknown label "%s"' % (
+                    enum_type.full_name, value))
+        return value
+
+    def init(self, **kwargs):
+        self._cached_byte_size = 0
+        self._cached_byte_size_dirty = len(kwargs) > 0
+        self._fields = {}
+        # Contains a mapping from oneof field descriptors to the descriptor
+        # of the currently set field in that oneof field.
+        self._oneofs = {}
+
+        # _unknown_fields is () when empty for efficiency, and will be turned into
+        # a list if fields are added.
+        self._unknown_fields = ()
+        # _unknown_field_set is None when empty for efficiency, and will be
+        # turned into UnknownFieldSet struct if fields are added.
+        self._unknown_field_set = None  # pylint: disable=protected-access
+        self._is_present_in_parent = False
+        self._listener = message_listener_mod.NullMessageListener()
+        self._listener_for_children = _Listener(self)
+        for field_name, field_value in kwargs.items():
+            field = _GetFieldByName(message_descriptor, field_name)
+            if field is None:
+                raise TypeError('%s() got an unexpected keyword argument "%s"' %
+                                (message_descriptor.name, field_name))
+            if field_value is None:
+                # field=None is the same as no field at all.
+                continue
+            if field.label == _FieldDescriptor.LABEL_REPEATED:
+                copy = field._default_constructor(self)
+                if field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:  # Composite
+                    if _IsMapField(field):
+                        if _IsMessageMapField(field):
+                            for key in field_value:
+                                copy[key].MergeFrom(field_value[key])
+                        else:
+                            copy.update(field_value)
+                    else:
+                        for val in field_value:
+                            if isinstance(val, dict):
+                                copy.add(**val)
+                            else:
+                                copy.add().MergeFrom(val)
+                else:  # Scalar
+                    if field.cpp_type == _FieldDescriptor.CPPTYPE_ENUM:
+                        field_value = [_GetIntegerEnumValue(field.enum_type, val)
+                                       for val in field_value]
+                    copy.extend(field_value)
+                self._fields[field] = copy
+            elif field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:
+                copy = field._default_constructor(self)
+                new_val = field_value
+                if isinstance(field_value, dict):
+                    new_val = field.message_type._concrete_class(**field_value)
+                try:
+                    copy.MergeFrom(new_val)
+                except TypeError:
+                    _ReraiseTypeErrorWithFieldName(message_descriptor.name, field_name)
+                self._fields[field] = copy
+            else:
+                if field.cpp_type == _FieldDescriptor.CPPTYPE_ENUM:
+                    field_value = _GetIntegerEnumValue(field.enum_type, field_value)
+                try:
+                    setattr(self, field_name, field_value)
+                except TypeError:
+                    _ReraiseTypeErrorWithFieldName(message_descriptor.name, field_name)
+
+    init.__module__ = None
+    init.__doc__ = None
+    cls.__init__ = init
+
+
+def _GetFieldByName(message_descriptor, field_name):
+    """Returns a field descriptor by field name.
+
+    Args:
+      message_descriptor: A Descriptor describing all fields in message.
+      field_name: The name of the field to retrieve.
+    Returns:
+      The field descriptor associated with the field name.
+    """
+    try:
+        return message_descriptor.fields_by_name[field_name]
+    except KeyError:
+        raise ValueError('Protocol message %s has no "%s" field.' %
+                         (message_descriptor.name, field_name))
+
+
+def _AddPropertiesForFields(descriptor, cls):
+    """Adds properties for all fields in this protocol message type."""
+    for field in descriptor.fields:
+        _AddPropertiesForField(field, cls)
+
+    if descriptor.is_extendable:
+        # _ExtensionDict is just an adaptor with no state so we allocate a new one
+        # every time it is accessed.
+        cls.Extensions = property(lambda self: _ExtensionDict(self))
+
+
+def _AddPropertiesForField(field, cls):
+    """Adds a public property for a protocol message field.
+    Clients can use this property to get and (in the case
+    of non-repeated scalar fields) directly set the value
+    of a protocol message field.
+
+    Args:
+      field: A FieldDescriptor for this field.
+      cls: The class we're constructing.
+    """
+    # Catch it if we add other types that we should
+    # handle specially here.
+    assert _FieldDescriptor.MAX_CPPTYPE == 10
+
+    constant_name = field.name.upper() + '_FIELD_NUMBER'
+    setattr(cls, constant_name, field.number)
+
+    if field.label == _FieldDescriptor.LABEL_REPEATED:
+        _AddPropertiesForRepeatedField(field, cls)
+    elif field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:
+        _AddPropertiesForNonRepeatedCompositeField(field, cls)
+    else:
+        _AddPropertiesForNonRepeatedScalarField(field, cls)
+
+
+class _FieldProperty(property):
+    __slots__ = ('DESCRIPTOR',)
+
+    def __init__(self, descriptor, getter, setter, doc):
+        property.__init__(self, getter, setter, doc=doc)
+        self.DESCRIPTOR = descriptor
+
+
+def _AddPropertiesForRepeatedField(field, cls):
+    """Adds a public property for a "repeated" protocol message field.  Clients
+    can use this property to get the value of the field, which will be either a
+    RepeatedScalarFieldContainer or RepeatedCompositeFieldContainer (see
+    below).
+
+    Note that when clients add values to these containers, we perform
+    type-checking in the case of repeated scalar fields, and we also set any
+    necessary "has" bits as a side-effect.
+
+    Args:
+      field: A FieldDescriptor for this field.
+      cls: The class we're constructing.
+    """
+    proto_field_name = field.name
+    property_name = _PropertyName(proto_field_name)
+
+    def getter(self):
+        field_value = self._fields.get(field)
+        if field_value is None:
+            # Construct a new object to represent this field.
+            field_value = field._default_constructor(self)
+
+            # Atomically check if another thread has preempted us and, if not, swap
+            # in the new object we just created.  If someone has preempted us, we
+            # take that object and discard ours.
+            # WARNING:  We are relying on setdefault() being atomic.  This is true
+            #   in CPython but we haven't investigated others.  This warning appears
+            #   in several other locations in this file.
+            field_value = self._fields.setdefault(field, field_value)
+        return field_value
+
+    getter.__module__ = None
+    getter.__doc__ = 'Getter for %s.' % proto_field_name
+
+    # We define a setter just so we can throw an exception with a more
+    # helpful error message.
+    def setter(self, new_value):
+        raise AttributeError('Assignment not allowed to repeated field '
+                             '"%s" in protocol message object.' % proto_field_name)
+
+    doc = 'Magic attribute generated for "%s" proto field.' % proto_field_name
+    setattr(cls, property_name, _FieldProperty(field, getter, setter, doc=doc))
+
+
+def _AddPropertiesForNonRepeatedScalarField(field, cls):
+    """Adds a public property for a nonrepeated, scalar protocol message field.
+    Clients can use this property to get and directly set the value of the field.
+    Note that when the client sets the value of a field by using this property,
+    all necessary "has" bits are set as a side-effect, and we also perform
+    type-checking.
+
+    Args:
+      field: A FieldDescriptor for this field.
+      cls: The class we're constructing.
+    """
+    proto_field_name = field.name
+    property_name = _PropertyName(proto_field_name)
+    type_checker = type_checkers.GetTypeChecker(field)
+    default_value = field.default_value
+    is_proto3 = field.containing_type.syntax == 'proto3'
+
+    def getter(self):
+        # TODO(protobuf-team): This may be broken since there may not be
+        # default_value.  Combine with has_default_value somehow.
+        return self._fields.get(field, default_value)
+
+    getter.__module__ = None
+    getter.__doc__ = 'Getter for %s.' % proto_field_name
+
+    clear_when_set_to_default = is_proto3 and not field.containing_oneof
+
+    def field_setter(self, new_value):
+        # pylint: disable=protected-access
+        # Testing the value for truthiness captures all of the proto3 defaults
+        # (0, 0.0, enum 0, and False).
+        try:
+            new_value = type_checker.CheckValue(new_value)
+        except TypeError as e:
+            raise TypeError(
+                'Cannot set %s to %.1024r: %s' % (field.full_name, new_value, e))
+        if clear_when_set_to_default and not new_value:
+            self._fields.pop(field, None)
+        else:
+            self._fields[field] = new_value
+        # Check _cached_byte_size_dirty inline to improve performance, since scalar
+        # setters are called frequently.
+        if not self._cached_byte_size_dirty:
+            self._Modified()
+
+    if field.containing_oneof:
+        def setter(self, new_value):
+            field_setter(self, new_value)
+            self._UpdateOneofState(field)
+    else:
+        setter = field_setter
+
+    setter.__module__ = None
+    setter.__doc__ = 'Setter for %s.' % proto_field_name
+
+    # Add a property to encapsulate the getter/setter.
+    doc = 'Magic attribute generated for "%s" proto field.' % proto_field_name
+    setattr(cls, property_name, _FieldProperty(field, getter, setter, doc=doc))
+
+
+def _AddPropertiesForNonRepeatedCompositeField(field, cls):
+    """Adds a public property for a nonrepeated, composite protocol message field.
+    A composite field is a "group" or "message" field.
+
+    Clients can use this property to get the value of the field, but cannot
+    assign to the property directly.
+
+    Args:
+      field: A FieldDescriptor for this field.
+      cls: The class we're constructing.
+    """
+    # TODO(robinson): Remove duplication with similar method
+    # for non-repeated scalars.
+    proto_field_name = field.name
+    property_name = _PropertyName(proto_field_name)
+
+    def getter(self):
+        field_value = self._fields.get(field)
+        if field_value is None:
+            # Construct a new object to represent this field.
+            field_value = field._default_constructor(self)
+
+            # Atomically check if another thread has preempted us and, if not, swap
+            # in the new object we just created.  If someone has preempted us, we
+            # take that object and discard ours.
+            # WARNING:  We are relying on setdefault() being atomic.  This is true
+            #   in CPython but we haven't investigated others.  This warning appears
+            #   in several other locations in this file.
+            field_value = self._fields.setdefault(field, field_value)
+        return field_value
+
+    getter.__module__ = None
+    getter.__doc__ = 'Getter for %s.' % proto_field_name
+
+    # We define a setter just so we can throw an exception with a more
+    # helpful error message.
+    def setter(self, new_value):
+        raise AttributeError('Assignment not allowed to composite field '
+                             '"%s" in protocol message object.' % proto_field_name)
+
+    # Add a property to encapsulate the getter.
+    doc = 'Magic attribute generated for "%s" proto field.' % proto_field_name
+    setattr(cls, property_name, _FieldProperty(field, getter, setter, doc=doc))
+
+
+def _AddPropertiesForExtensions(descriptor, cls):
+    """Adds properties for all fields in this protocol message type."""
+    extensions = descriptor.extensions_by_name
+    for extension_name, extension_field in extensions.items():
+        constant_name = extension_name.upper() + '_FIELD_NUMBER'
+        setattr(cls, constant_name, extension_field.number)
+
+    # TODO(amauryfa): Migrate all users of these attributes to functions like
+    #   pool.FindExtensionByNumber(descriptor).
+    if descriptor.file is not None:
+        # TODO(amauryfa): Use cls.MESSAGE_FACTORY.pool when available.
+        pool = descriptor.file.pool
+        cls._extensions_by_number = pool._extensions_by_number[descriptor]
+        cls._extensions_by_name = pool._extensions_by_name[descriptor]
+
+
+def _AddStaticMethods(cls):
+    # TODO(robinson): This probably needs to be thread-safe(?)
+    def RegisterExtension(extension_handle):
+        extension_handle.containing_type = cls.DESCRIPTOR
+        # TODO(amauryfa): Use cls.MESSAGE_FACTORY.pool when available.
+        # pylint: disable=protected-access
+        cls.DESCRIPTOR.file.pool._AddExtensionDescriptor(extension_handle)
+        _AttachFieldHelpers(cls, extension_handle)
+
+    cls.RegisterExtension = staticmethod(RegisterExtension)
+
+    def FromString(s):
+        message = cls()
+        message.MergeFromString(s)
+        return message
+
+    cls.FromString = staticmethod(FromString)
+
+
+def _IsPresent(item):
+    """Given a (FieldDescriptor, value) tuple from _fields, return true if the
+    value should be included in the list returned by ListFields()."""
+
+    if item[0].label == _FieldDescriptor.LABEL_REPEATED:
+        return bool(item[1])
+    elif item[0].cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:
+        return item[1]._is_present_in_parent
+    else:
+        return True
+
+
+def _AddListFieldsMethod(message_descriptor, cls):
+    """Helper for _AddMessageMethods()."""
+
+    def ListFields(self):
+        all_fields = [item for item in self._fields.items() if _IsPresent(item)]
+        all_fields.sort(key=lambda item: item[0].number)
+        return all_fields
+
+    cls.ListFields = ListFields
+
+
+_PROTO3_ERROR_TEMPLATE = \
+    ('Protocol message %s has no non-repeated submessage field "%s" '
+     'nor marked as optional')
+_PROTO2_ERROR_TEMPLATE = 'Protocol message %s has no non-repeated field "%s"'
+
+
+def _AddHasFieldMethod(message_descriptor, cls):
+    """Helper for _AddMessageMethods()."""
+
+    is_proto3 = (message_descriptor.syntax == "proto3")
+    error_msg = _PROTO3_ERROR_TEMPLATE if is_proto3 else _PROTO2_ERROR_TEMPLATE
+
+    hassable_fields = {}
+    for field in message_descriptor.fields:
+        if field.label == _FieldDescriptor.LABEL_REPEATED:
+            continue
+        # For proto3, only submessages and fields inside a oneof have presence.
+        if (is_proto3 and field.cpp_type != _FieldDescriptor.CPPTYPE_MESSAGE and
+                not field.containing_oneof):
+            continue
+        hassable_fields[field.name] = field
+
+    # Has methods are supported for oneof descriptors.
+    for oneof in message_descriptor.oneofs:
+        hassable_fields[oneof.name] = oneof
+
+    def HasField(self, field_name):
+        try:
+            field = hassable_fields[field_name]
+        except KeyError:
+            raise ValueError(error_msg % (message_descriptor.full_name, field_name))
+
+        if isinstance(field, descriptor_mod.OneofDescriptor):
+            try:
+                return HasField(self, self._oneofs[field].name)
+            except KeyError:
+                return False
+        else:
+            if field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:
+                value = self._fields.get(field)
+                return value is not None and value._is_present_in_parent
+            else:
+                return field in self._fields
+
+    cls.HasField = HasField
+
+
+def _AddClearFieldMethod(message_descriptor, cls):
+    """Helper for _AddMessageMethods()."""
+
+    def ClearField(self, field_name):
+        try:
+            field = message_descriptor.fields_by_name[field_name]
+        except KeyError:
+            try:
+                field = message_descriptor.oneofs_by_name[field_name]
+                if field in self._oneofs:
+                    field = self._oneofs[field]
+                else:
+                    return
+            except KeyError:
+                raise ValueError('Protocol message %s has no "%s" field.' %
+                                 (message_descriptor.name, field_name))
+
+        if field in self._fields:
+            # To match the C++ implementation, we need to invalidate iterators
+            # for map fields when ClearField() happens.
+            if hasattr(self._fields[field], 'InvalidateIterators'):
+                self._fields[field].InvalidateIterators()
+
+            # Note:  If the field is a sub-message, its listener will still point
+            #   at us.  That's fine, because the worst than can happen is that it
+            #   will call _Modified() and invalidate our byte size.  Big deal.
+            del self._fields[field]
+
+            if self._oneofs.get(field.containing_oneof, None) is field:
+                del self._oneofs[field.containing_oneof]
+
+        # Always call _Modified() -- even if nothing was changed, this is
+        # a mutating method, and thus calling it should cause the field to become
+        # present in the parent message.
+        self._Modified()
+
+    cls.ClearField = ClearField
+
+
+def _AddClearExtensionMethod(cls):
+    """Helper for _AddMessageMethods()."""
+
+    def ClearExtension(self, extension_handle):
+        extension_dict._VerifyExtensionHandle(self, extension_handle)
+
+        # Similar to ClearField(), above.
+        if extension_handle in self._fields:
+            del self._fields[extension_handle]
+        self._Modified()
+
+    cls.ClearExtension = ClearExtension
+
+
+def _AddHasExtensionMethod(cls):
+    """Helper for _AddMessageMethods()."""
+
+    def HasExtension(self, extension_handle):
+        extension_dict._VerifyExtensionHandle(self, extension_handle)
+        if extension_handle.label == _FieldDescriptor.LABEL_REPEATED:
+            raise KeyError('"%s" is repeated.' % extension_handle.full_name)
+
+        if extension_handle.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:
+            value = self._fields.get(extension_handle)
+            return value is not None and value._is_present_in_parent
+        else:
+            return extension_handle in self._fields
+
+    cls.HasExtension = HasExtension
+
+
+def _InternalUnpackAny(msg):
+    """Unpacks Any message and returns the unpacked message.
+
+    This internal method is different from public Any Unpack method which takes
+    the target message as argument. _InternalUnpackAny method does not have
+    target message type and need to find the message type in descriptor pool.
+
+    Args:
+      msg: An Any message to be unpacked.
+
+    Returns:
+      The unpacked message.
+    """
+    # TODO(amauryfa): Don't use the factory of generated messages.
+    # To make Any work with custom factories, use the message factory of the
+    # parent message.
+    # pylint: disable=g-import-not-at-top
+    from lark_channel.ws.pb.google.protobuf import symbol_database
+    factory = symbol_database.Default()
+
+    type_url = msg.type_url
+
+    if not type_url:
+        return None
+
+    # TODO(haberman): For now we just strip the hostname.  Better logic will be
+    # required.
+    type_name = type_url.split('/')[-1]
+    descriptor = factory.pool.FindMessageTypeByName(type_name)
+
+    if descriptor is None:
+        return None
+
+    message_class = factory.GetPrototype(descriptor)
+    message = message_class()
+
+    message.ParseFromString(msg.value)
+    return message
+
+
+def _AddEqualsMethod(message_descriptor, cls):
+    """Helper for _AddMessageMethods()."""
+
+    def __eq__(self, other):
+        if (not isinstance(other, message_mod.Message) or
+                other.DESCRIPTOR != self.DESCRIPTOR):
+            return False
+
+        if self is other:
+            return True
+
+        if self.DESCRIPTOR.full_name == _AnyFullTypeName:
+            any_a = _InternalUnpackAny(self)
+            any_b = _InternalUnpackAny(other)
+            if any_a and any_b:
+                return any_a == any_b
+
+        if not self.ListFields() == other.ListFields():
+            return False
+
+        # TODO(jieluo): Fix UnknownFieldSet to consider MessageSet extensions,
+        # then use it for the comparison.
+        unknown_fields = list(self._unknown_fields)
+        unknown_fields.sort()
+        other_unknown_fields = list(other._unknown_fields)
+        other_unknown_fields.sort()
+        return unknown_fields == other_unknown_fields
+
+    cls.__eq__ = __eq__
+
+
+def _AddStrMethod(message_descriptor, cls):
+    """Helper for _AddMessageMethods()."""
+
+    def __str__(self):
+        return text_format.MessageToString(self)
+
+    cls.__str__ = __str__
+
+
+def _AddReprMethod(message_descriptor, cls):
+    """Helper for _AddMessageMethods()."""
+
+    def __repr__(self):
+        return text_format.MessageToString(self)
+
+    cls.__repr__ = __repr__
+
+
+def _AddUnicodeMethod(unused_message_descriptor, cls):
+    """Helper for _AddMessageMethods()."""
+
+    def __unicode__(self):
+        return text_format.MessageToString(self, as_utf8=True).decode('utf-8')
+
+    cls.__unicode__ = __unicode__
+
+
+def _BytesForNonRepeatedElement(value, field_number, field_type):
+    """Returns the number of bytes needed to serialize a non-repeated element.
+    The returned byte count includes space for tag information and any
+    other additional space associated with serializing value.
+
+    Args:
+      value: Value we're serializing.
+      field_number: Field number of this value.  (Since the field number
+        is stored as part of a varint-encoded tag, this has an impact
+        on the total bytes required to serialize the value).
+      field_type: The type of the field.  One of the TYPE_* constants
+        within FieldDescriptor.
+    """
+    try:
+        fn = type_checkers.TYPE_TO_BYTE_SIZE_FN[field_type]
+        return fn(field_number, value)
+    except KeyError:
+        raise message_mod.EncodeError('Unrecognized field type: %d' % field_type)
+
+
+def _AddByteSizeMethod(message_descriptor, cls):
+    """Helper for _AddMessageMethods()."""
+
+    def ByteSize(self):
+        if not self._cached_byte_size_dirty:
+            return self._cached_byte_size
+
+        size = 0
+        descriptor = self.DESCRIPTOR
+        if descriptor.GetOptions().map_entry:
+            # Fields of map entry should always be serialized.
+            size = descriptor.fields_by_name['key']._sizer(self.key)
+            size += descriptor.fields_by_name['value']._sizer(self.value)
+        else:
+            for field_descriptor, field_value in self.ListFields():
+                size += field_descriptor._sizer(field_value)
+            for tag_bytes, value_bytes in self._unknown_fields:
+                size += len(tag_bytes) + len(value_bytes)
+
+        self._cached_byte_size = size
+        self._cached_byte_size_dirty = False
+        self._listener_for_children.dirty = False
+        return size
+
+    cls.ByteSize = ByteSize
+
+
+def _AddSerializeToStringMethod(message_descriptor, cls):
+    """Helper for _AddMessageMethods()."""
+
+    def SerializeToString(self, **kwargs):
+        # Check if the message has all of its required fields set.
+        if not self.IsInitialized():
+            raise message_mod.EncodeError(
+                'Message %s is missing required fields: %s' % (
+                    self.DESCRIPTOR.full_name, ','.join(self.FindInitializationErrors())))
+        return self.SerializePartialToString(**kwargs)
+
+    cls.SerializeToString = SerializeToString
+
+
+def _AddSerializePartialToStringMethod(message_descriptor, cls):
+    """Helper for _AddMessageMethods()."""
+
+    def SerializePartialToString(self, **kwargs):
+        out = BytesIO()
+        self._InternalSerialize(out.write, **kwargs)
+        return out.getvalue()
+
+    cls.SerializePartialToString = SerializePartialToString
+
+    def InternalSerialize(self, write_bytes, deterministic=None):
+        if deterministic is None:
+            deterministic = (
+                api_implementation.IsPythonDefaultSerializationDeterministic())
+        else:
+            deterministic = bool(deterministic)
+
+        descriptor = self.DESCRIPTOR
+        if descriptor.GetOptions().map_entry:
+            # Fields of map entry should always be serialized.
+            descriptor.fields_by_name['key']._encoder(
+                write_bytes, self.key, deterministic)
+            descriptor.fields_by_name['value']._encoder(
+                write_bytes, self.value, deterministic)
+        else:
+            for field_descriptor, field_value in self.ListFields():
+                field_descriptor._encoder(write_bytes, field_value, deterministic)
+            for tag_bytes, value_bytes in self._unknown_fields:
+                write_bytes(tag_bytes)
+                write_bytes(value_bytes)
+
+    cls._InternalSerialize = InternalSerialize
+
+
+def _AddMergeFromStringMethod(message_descriptor, cls):
+    """Helper for _AddMessageMethods()."""
+
+    def MergeFromString(self, serialized):
+        serialized = memoryview(serialized)
+        length = len(serialized)
+        try:
+            if self._InternalParse(serialized, 0, length) != length:
+                # The only reason _InternalParse would return early is if it
+                # encountered an end-group tag.
+                raise message_mod.DecodeError('Unexpected end-group tag.')
+        except (IndexError, TypeError):
+            # Now ord(buf[p:p+1]) == ord('') gets TypeError.
+            raise message_mod.DecodeError('Truncated message.')
+        except struct.error as e:
+            raise message_mod.DecodeError(e)
+        return length  # Return this for legacy reasons.
+
+    cls.MergeFromString = MergeFromString
+
+    local_ReadTag = decoder.ReadTag
+    local_SkipField = decoder.SkipField
+    decoders_by_tag = cls._decoders_by_tag
+
+    def InternalParse(self, buffer, pos, end):
+        """Create a message from serialized bytes.
+
+        Args:
+          self: Message, instance of the proto message object.
+          buffer: memoryview of the serialized data.
+          pos: int, position to start in the serialized data.
+          end: int, end position of the serialized data.
+
+        Returns:
+          Message object.
+        """
+        # Guard against internal misuse, since this function is called internally
+        # quite extensively, and its easy to accidentally pass bytes.
+        assert isinstance(buffer, memoryview)
+        self._Modified()
+        field_dict = self._fields
+        # pylint: disable=protected-access
+        unknown_field_set = self._unknown_field_set
+        while pos != end:
+            (tag_bytes, new_pos) = local_ReadTag(buffer, pos)
+            field_decoder, field_desc = decoders_by_tag.get(tag_bytes, (None, None))
+            if field_decoder is None:
+                if not self._unknown_fields:  # pylint: disable=protected-access
+                    self._unknown_fields = []  # pylint: disable=protected-access
+                if unknown_field_set is None:
+                    # pylint: disable=protected-access
+                    self._unknown_field_set = containers.UnknownFieldSet()
+                    # pylint: disable=protected-access
+                    unknown_field_set = self._unknown_field_set
+                # pylint: disable=protected-access
+                (tag, _) = decoder._DecodeVarint(tag_bytes, 0)
+                field_number, wire_type = wire_format.UnpackTag(tag)
+                if field_number == 0:
+                    raise message_mod.DecodeError('Field number 0 is illegal.')
+                # TODO(jieluo): remove old_pos.
+                old_pos = new_pos
+                (data, new_pos) = decoder._DecodeUnknownField(
+                    buffer, new_pos, wire_type)  # pylint: disable=protected-access
+                if new_pos == -1:
+                    return pos
+                # pylint: disable=protected-access
+                unknown_field_set._add(field_number, wire_type, data)
+                # TODO(jieluo): remove _unknown_fields.
+                new_pos = local_SkipField(buffer, old_pos, end, tag_bytes)
+                if new_pos == -1:
+                    return pos
+                self._unknown_fields.append(
+                    (tag_bytes, buffer[old_pos:new_pos].tobytes()))
+                pos = new_pos
+            else:
+                pos = field_decoder(buffer, new_pos, end, self, field_dict)
+                if field_desc:
+                    self._UpdateOneofState(field_desc)
+        return pos
+
+    cls._InternalParse = InternalParse
+
+
+def _AddIsInitializedMethod(message_descriptor, cls):
+    """Adds the IsInitialized and FindInitializationError methods to the
+    protocol message class."""
+
+    required_fields = [field for field in message_descriptor.fields
+                       if field.label == _FieldDescriptor.LABEL_REQUIRED]
+
+    def IsInitialized(self, errors=None):
+        """Checks if all required fields of a message are set.
+
+        Args:
+          errors:  A list which, if provided, will be populated with the field
+                   paths of all missing required fields.
+
+        Returns:
+          True iff the specified message has all required fields set.
+        """
+
+        # Performance is critical so we avoid HasField() and ListFields().
+
+        for field in required_fields:
+            if (field not in self._fields or
+                    (field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE and
+                     not self._fields[field]._is_present_in_parent)):
+                if errors is not None:
+                    errors.extend(self.FindInitializationErrors())
+                return False
+
+        for field, value in list(self._fields.items()):  # dict can change size!
+            if field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:
+                if field.label == _FieldDescriptor.LABEL_REPEATED:
+                    if (field.message_type.has_options and
+                            field.message_type.GetOptions().map_entry):
+                        continue
+                    for element in value:
+                        if not element.IsInitialized():
+                            if errors is not None:
+                                errors.extend(self.FindInitializationErrors())
+                            return False
+                elif value._is_present_in_parent and not value.IsInitialized():
+                    if errors is not None:
+                        errors.extend(self.FindInitializationErrors())
+                    return False
+
+        return True
+
+    cls.IsInitialized = IsInitialized
+
+    def FindInitializationErrors(self):
+        """Finds required fields which are not initialized.
+
+        Returns:
+          A list of strings.  Each string is a path to an uninitialized field from
+          the top-level message, e.g. "foo.bar[5].baz".
+        """
+
+        errors = []  # simplify things
+
+        for field in required_fields:
+            if not self.HasField(field.name):
+                errors.append(field.name)
+
+        for field, value in self.ListFields():
+            if field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:
+                if field.is_extension:
+                    name = '(%s)' % field.full_name
+                else:
+                    name = field.name
+
+                if _IsMapField(field):
+                    if _IsMessageMapField(field):
+                        for key in value:
+                            element = value[key]
+                            prefix = '%s[%s].' % (name, key)
+                            sub_errors = element.FindInitializationErrors()
+                            errors += [prefix + error for error in sub_errors]
+                    else:
+                        # ScalarMaps can't have any initialization errors.
+                        pass
+                elif field.label == _FieldDescriptor.LABEL_REPEATED:
+                    for i in range(len(value)):
+                        element = value[i]
+                        prefix = '%s[%d].' % (name, i)
+                        sub_errors = element.FindInitializationErrors()
+                        errors += [prefix + error for error in sub_errors]
+                else:
+                    prefix = name + '.'
+                    sub_errors = value.FindInitializationErrors()
+                    errors += [prefix + error for error in sub_errors]
+
+        return errors
+
+    cls.FindInitializationErrors = FindInitializationErrors
+
+
+def _FullyQualifiedClassName(klass):
+    module = klass.__module__
+    name = getattr(klass, '__qualname__', klass.__name__)
+    if module in (None, 'builtins', '__builtin__'):
+        return name
+    return module + '.' + name
+
+
+def _AddMergeFromMethod(cls):
+    LABEL_REPEATED = _FieldDescriptor.LABEL_REPEATED
+    CPPTYPE_MESSAGE = _FieldDescriptor.CPPTYPE_MESSAGE
+
+    def MergeFrom(self, msg):
+        if not isinstance(msg, cls):
+            raise TypeError(
+                'Parameter to MergeFrom() must be instance of same class: '
+                'expected %s got %s.' % (_FullyQualifiedClassName(cls),
+                                         _FullyQualifiedClassName(msg.__class__)))
+
+        assert msg is not self
+        self._Modified()
+
+        fields = self._fields
+
+        for field, value in msg._fields.items():
+            if field.label == LABEL_REPEATED:
+                field_value = fields.get(field)
+                if field_value is None:
+                    # Construct a new object to represent this field.
+                    field_value = field._default_constructor(self)
+                    fields[field] = field_value
+                field_value.MergeFrom(value)
+            elif field.cpp_type == CPPTYPE_MESSAGE:
+                if value._is_present_in_parent:
+                    field_value = fields.get(field)
+                    if field_value is None:
+                        # Construct a new object to represent this field.
+                        field_value = field._default_constructor(self)
+                        fields[field] = field_value
+                    field_value.MergeFrom(value)
+            else:
+                self._fields[field] = value
+                if field.containing_oneof:
+                    self._UpdateOneofState(field)
+
+        if msg._unknown_fields:
+            if not self._unknown_fields:
+                self._unknown_fields = []
+            self._unknown_fields.extend(msg._unknown_fields)
+            # pylint: disable=protected-access
+            if self._unknown_field_set is None:
+                self._unknown_field_set = containers.UnknownFieldSet()
+            self._unknown_field_set._extend(msg._unknown_field_set)
+
+    cls.MergeFrom = MergeFrom
+
+
+def _AddWhichOneofMethod(message_descriptor, cls):
+    def WhichOneof(self, oneof_name):
+        """Returns the name of the currently set field inside a oneof, or None."""
+        try:
+            field = message_descriptor.oneofs_by_name[oneof_name]
+        except KeyError:
+            raise ValueError(
+                'Protocol message has no oneof "%s" field.' % oneof_name)
+
+        nested_field = self._oneofs.get(field, None)
+        if nested_field is not None and self.HasField(nested_field.name):
+            return nested_field.name
+        else:
+            return None
+
+    cls.WhichOneof = WhichOneof
+
+
+def _Clear(self):
+    # Clear fields.
+    self._fields = {}
+    self._unknown_fields = ()
+    # pylint: disable=protected-access
+    if self._unknown_field_set is not None:
+        self._unknown_field_set._clear()
+        self._unknown_field_set = None
+
+    self._oneofs = {}
+    self._Modified()
+
+
+def _UnknownFields(self):
+    if self._unknown_field_set is None:  # pylint: disable=protected-access
+        # pylint: disable=protected-access
+        self._unknown_field_set = containers.UnknownFieldSet()
+    return self._unknown_field_set  # pylint: disable=protected-access
+
+
+def _DiscardUnknownFields(self):
+    self._unknown_fields = []
+    self._unknown_field_set = None  # pylint: disable=protected-access
+    for field, value in self.ListFields():
+        if field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:
+            if _IsMapField(field):
+                if _IsMessageMapField(field):
+                    for key in value:
+                        value[key].DiscardUnknownFields()
+            elif field.label == _FieldDescriptor.LABEL_REPEATED:
+                for sub_message in value:
+                    sub_message.DiscardUnknownFields()
+            else:
+                value.DiscardUnknownFields()
+
+
+def _SetListener(self, listener):
+    if listener is None:
+        self._listener = message_listener_mod.NullMessageListener()
+    else:
+        self._listener = listener
+
+
+def _AddMessageMethods(message_descriptor, cls):
+    """Adds implementations of all Message methods to cls."""
+    _AddListFieldsMethod(message_descriptor, cls)
+    _AddHasFieldMethod(message_descriptor, cls)
+    _AddClearFieldMethod(message_descriptor, cls)
+    if message_descriptor.is_extendable:
+        _AddClearExtensionMethod(cls)
+        _AddHasExtensionMethod(cls)
+    _AddEqualsMethod(message_descriptor, cls)
+    _AddStrMethod(message_descriptor, cls)
+    _AddReprMethod(message_descriptor, cls)
+    _AddUnicodeMethod(message_descriptor, cls)
+    _AddByteSizeMethod(message_descriptor, cls)
+    _AddSerializeToStringMethod(message_descriptor, cls)
+    _AddSerializePartialToStringMethod(message_descriptor, cls)
+    _AddMergeFromStringMethod(message_descriptor, cls)
+    _AddIsInitializedMethod(message_descriptor, cls)
+    _AddMergeFromMethod(cls)
+    _AddWhichOneofMethod(message_descriptor, cls)
+    # Adds methods which do not depend on cls.
+    cls.Clear = _Clear
+    cls.UnknownFields = _UnknownFields
+    cls.DiscardUnknownFields = _DiscardUnknownFields
+    cls._SetListener = _SetListener
+
+
+def _AddPrivateHelperMethods(message_descriptor, cls):
+    """Adds implementation of private helper methods to cls."""
+
+    def Modified(self):
+        """Sets the _cached_byte_size_dirty bit to true,
+        and propagates this to our listener iff this was a state change.
+        """
+
+        # Note:  Some callers check _cached_byte_size_dirty before calling
+        #   _Modified() as an extra optimization.  So, if this method is ever
+        #   changed such that it does stuff even when _cached_byte_size_dirty is
+        #   already true, the callers need to be updated.
+        if not self._cached_byte_size_dirty:
+            self._cached_byte_size_dirty = True
+            self._listener_for_children.dirty = True
+            self._is_present_in_parent = True
+            self._listener.Modified()
+
+    def _UpdateOneofState(self, field):
+        """Sets field as the active field in its containing oneof.
+
+        Will also delete currently active field in the oneof, if it is different
+        from the argument. Does not mark the message as modified.
+        """
+        other_field = self._oneofs.setdefault(field.containing_oneof, field)
+        if other_field is not field:
+            del self._fields[other_field]
+            self._oneofs[field.containing_oneof] = field
+
+    cls._Modified = Modified
+    cls.SetInParent = Modified
+    cls._UpdateOneofState = _UpdateOneofState
+
+
+class _Listener(object):
+    """MessageListener implementation that a parent message registers with its
+    child message.
+
+    In order to support semantics like:
+
+      foo.bar.baz.qux = 23
+      assert foo.HasField('bar')
+
+    ...child objects must have back references to their parents.
+    This helper class is at the heart of this support.
+    """
+
+    def __init__(self, parent_message):
+        """Args:
+          parent_message: The message whose _Modified() method we should call when
+            we receive Modified() messages.
+        """
+        # This listener establishes a back reference from a child (contained) object
+        # to its parent (containing) object.  We make this a weak reference to avoid
+        # creating cyclic garbage when the client finishes with the 'parent' object
+        # in the tree.
+        if isinstance(parent_message, weakref.ProxyType):
+            self._parent_message_weakref = parent_message
+        else:
+            self._parent_message_weakref = weakref.proxy(parent_message)
+
+        # As an optimization, we also indicate directly on the listener whether
+        # or not the parent message is dirty.  This way we can avoid traversing
+        # up the tree in the common case.
+        self.dirty = False
+
+    def Modified(self):
+        if self.dirty:
+            return
+        try:
+            # Propagate the signal to our parents iff this is the first field set.
+            self._parent_message_weakref._Modified()
+        except ReferenceError:
+            # We can get here if a client has kept a reference to a child object,
+            # and is now setting a field on it, but the child's parent has been
+            # garbage-collected.  This is not an error.
+            pass
+
+
+class _OneofListener(_Listener):
+    """Special listener implementation for setting composite oneof fields."""
+
+    def __init__(self, parent_message, field):
+        """Args:
+          parent_message: The message whose _Modified() method we should call when
+            we receive Modified() messages.
+          field: The descriptor of the field being set in the parent message.
+        """
+        super(_OneofListener, self).__init__(parent_message)
+        self._field = field
+
+    def Modified(self):
+        """Also updates the state of the containing oneof in the parent message."""
+        try:
+            self._parent_message_weakref._UpdateOneofState(self._field)
+            super(_OneofListener, self).Modified()
+        except ReferenceError:
+            pass
diff --git a/lark_channel/ws/pb/google/protobuf/internal/python_protobuf.cc b/lark_channel/ws/pb/google/protobuf/internal/python_protobuf.cc
new file mode 100644
index 0000000..26e3a8b
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/internal/python_protobuf.cc
@@ -0,0 +1,63 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: qrczak@google.com (Marcin Kowalczyk)
+
+#include <google/protobuf/python/python_protobuf.h>
+
+namespace google {
+namespace protobuf {
+namespace python {
+
+static const Message* GetCProtoInsidePyProtoStub(PyObject* msg) {
+  return nullptr;
+}
+static Message* MutableCProtoInsidePyProtoStub(PyObject* msg) {
+  return nullptr;
+}
+
+// This is initialized with a default, stub implementation.
+// If python-google.protobuf.cc is loaded, the function pointer is overridden
+// with a full implementation.
+const Message* (*GetCProtoInsidePyProtoPtr)(PyObject* msg) =
+    GetCProtoInsidePyProtoStub;
+Message* (*MutableCProtoInsidePyProtoPtr)(PyObject* msg) =
+    MutableCProtoInsidePyProtoStub;
+
+const Message* GetCProtoInsidePyProto(PyObject* msg) {
+  return GetCProtoInsidePyProtoPtr(msg);
+}
+Message* MutableCProtoInsidePyProto(PyObject* msg) {
+  return MutableCProtoInsidePyProtoPtr(msg);
+}
+
+}  // namespace python
+}  // namespace protobuf
+}  // namespace google
diff --git a/lark_channel/ws/pb/google/protobuf/internal/type_checkers.py b/lark_channel/ws/pb/google/protobuf/internal/type_checkers.py
new file mode 100644
index 0000000..337e512
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/internal/type_checkers.py
@@ -0,0 +1,428 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+# https://developers.google.com/protocol-buffers/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""Provides type checking routines.
+
+This module defines type checking utilities in the forms of dictionaries:
+
+VALUE_CHECKERS: A dictionary of field types and a value validation object.
+TYPE_TO_BYTE_SIZE_FN: A dictionary with field types and a size computing
+  function.
+TYPE_TO_SERIALIZE_METHOD: A dictionary with field types and serialization
+  function.
+FIELD_TYPE_TO_WIRE_TYPE: A dictionary with field typed and their
+  corresponding wire types.
+TYPE_TO_DESERIALIZE_METHOD: A dictionary with field types and deserialization
+  function.
+"""
+
+__author__ = 'robinson@google.com (Will Robinson)'
+
+import ctypes
+import numbers
+
+from lark_channel.ws.pb.google.protobuf.internal import decoder
+from lark_channel.ws.pb.google.protobuf.internal import encoder
+from lark_channel.ws.pb.google.protobuf.internal import wire_format
+from lark_channel.ws.pb.google.protobuf import descriptor
+
+_FieldDescriptor = descriptor.FieldDescriptor
+
+
+def TruncateToFourByteFloat(original):
+    return ctypes.c_float(original).value
+
+
+def ToShortestFloat(original):
+    """Returns the shortest float that has same value in wire."""
+    # All 4 byte floats have between 6 and 9 significant digits, so we
+    # start with 6 as the lower bound.
+    # It has to be iterative because use '.9g' directly can not get rid
+    # of the noises for most values. For example if set a float_field=0.9
+    # use '.9g' will print 0.899999976.
+    precision = 6
+    rounded = float('{0:.{1}g}'.format(original, precision))
+    while TruncateToFourByteFloat(rounded) != original:
+        precision += 1
+        rounded = float('{0:.{1}g}'.format(original, precision))
+    return rounded
+
+
+def SupportsOpenEnums(field_descriptor):
+    return field_descriptor.containing_type.syntax == 'proto3'
+
+
+def GetTypeChecker(field):
+    """Returns a type checker for a message field of the specified types.
+
+    Args:
+      field: FieldDescriptor object for this field.
+
+    Returns:
+      An instance of TypeChecker which can be used to verify the types
+      of values assigned to a field of the specified type.
+    """
+    if (field.cpp_type == _FieldDescriptor.CPPTYPE_STRING and
+            field.type == _FieldDescriptor.TYPE_STRING):
+        return UnicodeValueChecker()
+    if field.cpp_type == _FieldDescriptor.CPPTYPE_ENUM:
+        if SupportsOpenEnums(field):
+            # When open enums are supported, any int32 can be assigned.
+            return _VALUE_CHECKERS[_FieldDescriptor.CPPTYPE_INT32]
+        else:
+            return EnumValueChecker(field.enum_type)
+    return _VALUE_CHECKERS[field.cpp_type]
+
+
+# None of the typecheckers below make any attempt to guard against people
+# subclassing builtin types and doing weird things.  We're not trying to
+# protect against malicious clients here, just people accidentally shooting
+# themselves in the foot in obvious ways.
+class TypeChecker(object):
+    """Type checker used to catch type errors as early as possible
+    when the client is setting scalar fields in protocol messages.
+    """
+
+    def __init__(self, *acceptable_types):
+        self._acceptable_types = acceptable_types
+
+    def CheckValue(self, proposed_value):
+        """Type check the provided value and return it.
+
+        The returned value might have been normalized to another type.
+        """
+        if not isinstance(proposed_value, self._acceptable_types):
+            message = ('%.1024r has type %s, but expected one of: %s' %
+                       (proposed_value, type(proposed_value), self._acceptable_types))
+            raise TypeError(message)
+        return proposed_value
+
+
+class TypeCheckerWithDefault(TypeChecker):
+
+    def __init__(self, default_value, *acceptable_types):
+        TypeChecker.__init__(self, *acceptable_types)
+        self._default_value = default_value
+
+    def DefaultValue(self):
+        return self._default_value
+
+
+class BoolValueChecker(object):
+    """Type checker used for bool fields."""
+
+    def CheckValue(self, proposed_value):
+        if not hasattr(proposed_value, '__index__') or (
+                type(proposed_value).__module__ == 'numpy' and
+                type(proposed_value).__name__ == 'ndarray'):
+            message = ('%.1024r has type %s, but expected one of: %s' %
+                       (proposed_value, type(proposed_value), (bool, int)))
+            raise TypeError(message)
+        return bool(proposed_value)
+
+    def DefaultValue(self):
+        return False
+
+
+# IntValueChecker and its subclasses perform integer type-checks
+# and bounds-checks.
+class IntValueChecker(object):
+    """Checker used for integer fields.  Performs type-check and range check."""
+
+    def CheckValue(self, proposed_value):
+        if not hasattr(proposed_value, '__index__') or (
+                type(proposed_value).__module__ == 'numpy' and
+                type(proposed_value).__name__ == 'ndarray'):
+            message = ('%.1024r has type %s, but expected one of: %s' %
+                       (proposed_value, type(proposed_value), (int,)))
+            raise TypeError(message)
+
+        if not self._MIN <= int(proposed_value) <= self._MAX:
+            raise ValueError('Value out of range: %d' % proposed_value)
+        # We force all values to int to make alternate implementations where the
+        # distinction is more significant (e.g. the C++ implementation) simpler.
+        proposed_value = int(proposed_value)
+        return proposed_value
+
+    def DefaultValue(self):
+        return 0
+
+
+class EnumValueChecker(object):
+    """Checker used for enum fields.  Performs type-check and range check."""
+
+    def __init__(self, enum_type):
+        self._enum_type = enum_type
+
+    def CheckValue(self, proposed_value):
+        if not isinstance(proposed_value, numbers.Integral):
+            message = ('%.1024r has type %s, but expected one of: %s' %
+                       (proposed_value, type(proposed_value), (int,)))
+            raise TypeError(message)
+        if int(proposed_value) not in self._enum_type.values_by_number:
+            raise ValueError('Unknown enum value: %d' % proposed_value)
+        return proposed_value
+
+    def DefaultValue(self):
+        return self._enum_type.values[0].number
+
+
+class UnicodeValueChecker(object):
+    """Checker used for string fields.
+
+    Always returns a unicode value, even if the input is of type str.
+    """
+
+    def CheckValue(self, proposed_value):
+        if not isinstance(proposed_value, (bytes, str)):
+            message = ('%.1024r has type %s, but expected one of: %s' %
+                       (proposed_value, type(proposed_value), (bytes, str)))
+            raise TypeError(message)
+
+        # If the value is of type 'bytes' make sure that it is valid UTF-8 data.
+        if isinstance(proposed_value, bytes):
+            try:
+                proposed_value = proposed_value.decode('utf-8')
+            except UnicodeDecodeError:
+                raise ValueError('%.1024r has type bytes, but isn\'t valid UTF-8 '
+                                 'encoding. Non-UTF-8 strings must be converted to '
+                                 'unicode objects before being added.' %
+                                 (proposed_value))
+        else:
+            try:
+                proposed_value.encode('utf8')
+            except UnicodeEncodeError:
+                raise ValueError('%.1024r isn\'t a valid unicode string and '
+                                 'can\'t be encoded in UTF-8.' %
+                                 (proposed_value))
+
+        return proposed_value
+
+    def DefaultValue(self):
+        return u""
+
+
+class Int32ValueChecker(IntValueChecker):
+    # We're sure to use ints instead of longs here since comparison may be more
+    # efficient.
+    _MIN = -2147483648
+    _MAX = 2147483647
+
+
+class Uint32ValueChecker(IntValueChecker):
+    _MIN = 0
+    _MAX = (1 << 32) - 1
+
+
+class Int64ValueChecker(IntValueChecker):
+    _MIN = -(1 << 63)
+    _MAX = (1 << 63) - 1
+
+
+class Uint64ValueChecker(IntValueChecker):
+    _MIN = 0
+    _MAX = (1 << 64) - 1
+
+
+# The max 4 bytes float is about 3.4028234663852886e+38
+_FLOAT_MAX = float.fromhex('0x1.fffffep+127')
+_FLOAT_MIN = -_FLOAT_MAX
+_INF = float('inf')
+_NEG_INF = float('-inf')
+
+
+class DoubleValueChecker(object):
+    """Checker used for double fields.
+
+    Performs type-check and range check.
+    """
+
+    def CheckValue(self, proposed_value):
+        """Check and convert proposed_value to float."""
+        if (not hasattr(proposed_value, '__float__') and
+            not hasattr(proposed_value, '__index__')) or (
+                type(proposed_value).__module__ == 'numpy' and
+                type(proposed_value).__name__ == 'ndarray'):
+            message = ('%.1024r has type %s, but expected one of: int, float' %
+                       (proposed_value, type(proposed_value)))
+            raise TypeError(message)
+        return float(proposed_value)
+
+    def DefaultValue(self):
+        return 0.0
+
+
+class FloatValueChecker(DoubleValueChecker):
+    """Checker used for float fields.
+
+    Performs type-check and range check.
+
+    Values exceeding a 32-bit float will be converted to inf/-inf.
+    """
+
+    def CheckValue(self, proposed_value):
+        """Check and convert proposed_value to float."""
+        converted_value = super().CheckValue(proposed_value)
+        # This inf rounding matches the C++ proto SafeDoubleToFloat logic.
+        if converted_value > _FLOAT_MAX:
+            return _INF
+        if converted_value < _FLOAT_MIN:
+            return _NEG_INF
+
+        return TruncateToFourByteFloat(converted_value)
+
+
+# Type-checkers for all scalar CPPTYPEs.
+_VALUE_CHECKERS = {
+    _FieldDescriptor.CPPTYPE_INT32: Int32ValueChecker(),
+    _FieldDescriptor.CPPTYPE_INT64: Int64ValueChecker(),
+    _FieldDescriptor.CPPTYPE_UINT32: Uint32ValueChecker(),
+    _FieldDescriptor.CPPTYPE_UINT64: Uint64ValueChecker(),
+    _FieldDescriptor.CPPTYPE_DOUBLE: DoubleValueChecker(),
+    _FieldDescriptor.CPPTYPE_FLOAT: FloatValueChecker(),
+    _FieldDescriptor.CPPTYPE_BOOL: BoolValueChecker(),
+    _FieldDescriptor.CPPTYPE_STRING: TypeCheckerWithDefault(b'', bytes),
+}
+
+# Map from field type to a function F, such that F(field_num, value)
+# gives the total byte size for a value of the given type.  This
+# byte size includes tag information and any other additional space
+# associated with serializing "value".
+TYPE_TO_BYTE_SIZE_FN = {
+    _FieldDescriptor.TYPE_DOUBLE: wire_format.DoubleByteSize,
+    _FieldDescriptor.TYPE_FLOAT: wire_format.FloatByteSize,
+    _FieldDescriptor.TYPE_INT64: wire_format.Int64ByteSize,
+    _FieldDescriptor.TYPE_UINT64: wire_format.UInt64ByteSize,
+    _FieldDescriptor.TYPE_INT32: wire_format.Int32ByteSize,
+    _FieldDescriptor.TYPE_FIXED64: wire_format.Fixed64ByteSize,
+    _FieldDescriptor.TYPE_FIXED32: wire_format.Fixed32ByteSize,
+    _FieldDescriptor.TYPE_BOOL: wire_format.BoolByteSize,
+    _FieldDescriptor.TYPE_STRING: wire_format.StringByteSize,
+    _FieldDescriptor.TYPE_GROUP: wire_format.GroupByteSize,
+    _FieldDescriptor.TYPE_MESSAGE: wire_format.MessageByteSize,
+    _FieldDescriptor.TYPE_BYTES: wire_format.BytesByteSize,
+    _FieldDescriptor.TYPE_UINT32: wire_format.UInt32ByteSize,
+    _FieldDescriptor.TYPE_ENUM: wire_format.EnumByteSize,
+    _FieldDescriptor.TYPE_SFIXED32: wire_format.SFixed32ByteSize,
+    _FieldDescriptor.TYPE_SFIXED64: wire_format.SFixed64ByteSize,
+    _FieldDescriptor.TYPE_SINT32: wire_format.SInt32ByteSize,
+    _FieldDescriptor.TYPE_SINT64: wire_format.SInt64ByteSize
+}
+
+# Maps from field types to encoder constructors.
+TYPE_TO_ENCODER = {
+    _FieldDescriptor.TYPE_DOUBLE: encoder.DoubleEncoder,
+    _FieldDescriptor.TYPE_FLOAT: encoder.FloatEncoder,
+    _FieldDescriptor.TYPE_INT64: encoder.Int64Encoder,
+    _FieldDescriptor.TYPE_UINT64: encoder.UInt64Encoder,
+    _FieldDescriptor.TYPE_INT32: encoder.Int32Encoder,
+    _FieldDescriptor.TYPE_FIXED64: encoder.Fixed64Encoder,
+    _FieldDescriptor.TYPE_FIXED32: encoder.Fixed32Encoder,
+    _FieldDescriptor.TYPE_BOOL: encoder.BoolEncoder,
+    _FieldDescriptor.TYPE_STRING: encoder.StringEncoder,
+    _FieldDescriptor.TYPE_GROUP: encoder.GroupEncoder,
+    _FieldDescriptor.TYPE_MESSAGE: encoder.MessageEncoder,
+    _FieldDescriptor.TYPE_BYTES: encoder.BytesEncoder,
+    _FieldDescriptor.TYPE_UINT32: encoder.UInt32Encoder,
+    _FieldDescriptor.TYPE_ENUM: encoder.EnumEncoder,
+    _FieldDescriptor.TYPE_SFIXED32: encoder.SFixed32Encoder,
+    _FieldDescriptor.TYPE_SFIXED64: encoder.SFixed64Encoder,
+    _FieldDescriptor.TYPE_SINT32: encoder.SInt32Encoder,
+    _FieldDescriptor.TYPE_SINT64: encoder.SInt64Encoder,
+}
+
+# Maps from field types to sizer constructors.
+TYPE_TO_SIZER = {
+    _FieldDescriptor.TYPE_DOUBLE: encoder.DoubleSizer,
+    _FieldDescriptor.TYPE_FLOAT: encoder.FloatSizer,
+    _FieldDescriptor.TYPE_INT64: encoder.Int64Sizer,
+    _FieldDescriptor.TYPE_UINT64: encoder.UInt64Sizer,
+    _FieldDescriptor.TYPE_INT32: encoder.Int32Sizer,
+    _FieldDescriptor.TYPE_FIXED64: encoder.Fixed64Sizer,
+    _FieldDescriptor.TYPE_FIXED32: encoder.Fixed32Sizer,
+    _FieldDescriptor.TYPE_BOOL: encoder.BoolSizer,
+    _FieldDescriptor.TYPE_STRING: encoder.StringSizer,
+    _FieldDescriptor.TYPE_GROUP: encoder.GroupSizer,
+    _FieldDescriptor.TYPE_MESSAGE: encoder.MessageSizer,
+    _FieldDescriptor.TYPE_BYTES: encoder.BytesSizer,
+    _FieldDescriptor.TYPE_UINT32: encoder.UInt32Sizer,
+    _FieldDescriptor.TYPE_ENUM: encoder.EnumSizer,
+    _FieldDescriptor.TYPE_SFIXED32: encoder.SFixed32Sizer,
+    _FieldDescriptor.TYPE_SFIXED64: encoder.SFixed64Sizer,
+    _FieldDescriptor.TYPE_SINT32: encoder.SInt32Sizer,
+    _FieldDescriptor.TYPE_SINT64: encoder.SInt64Sizer,
+}
+
+# Maps from field type to a decoder constructor.
+TYPE_TO_DECODER = {
+    _FieldDescriptor.TYPE_DOUBLE: decoder.DoubleDecoder,
+    _FieldDescriptor.TYPE_FLOAT: decoder.FloatDecoder,
+    _FieldDescriptor.TYPE_INT64: decoder.Int64Decoder,
+    _FieldDescriptor.TYPE_UINT64: decoder.UInt64Decoder,
+    _FieldDescriptor.TYPE_INT32: decoder.Int32Decoder,
+    _FieldDescriptor.TYPE_FIXED64: decoder.Fixed64Decoder,
+    _FieldDescriptor.TYPE_FIXED32: decoder.Fixed32Decoder,
+    _FieldDescriptor.TYPE_BOOL: decoder.BoolDecoder,
+    _FieldDescriptor.TYPE_STRING: decoder.StringDecoder,
+    _FieldDescriptor.TYPE_GROUP: decoder.GroupDecoder,
+    _FieldDescriptor.TYPE_MESSAGE: decoder.MessageDecoder,
+    _FieldDescriptor.TYPE_BYTES: decoder.BytesDecoder,
+    _FieldDescriptor.TYPE_UINT32: decoder.UInt32Decoder,
+    _FieldDescriptor.TYPE_ENUM: decoder.EnumDecoder,
+    _FieldDescriptor.TYPE_SFIXED32: decoder.SFixed32Decoder,
+    _FieldDescriptor.TYPE_SFIXED64: decoder.SFixed64Decoder,
+    _FieldDescriptor.TYPE_SINT32: decoder.SInt32Decoder,
+    _FieldDescriptor.TYPE_SINT64: decoder.SInt64Decoder,
+}
+
+# Maps from field type to expected wiretype.
+FIELD_TYPE_TO_WIRE_TYPE = {
+    _FieldDescriptor.TYPE_DOUBLE: wire_format.WIRETYPE_FIXED64,
+    _FieldDescriptor.TYPE_FLOAT: wire_format.WIRETYPE_FIXED32,
+    _FieldDescriptor.TYPE_INT64: wire_format.WIRETYPE_VARINT,
+    _FieldDescriptor.TYPE_UINT64: wire_format.WIRETYPE_VARINT,
+    _FieldDescriptor.TYPE_INT32: wire_format.WIRETYPE_VARINT,
+    _FieldDescriptor.TYPE_FIXED64: wire_format.WIRETYPE_FIXED64,
+    _FieldDescriptor.TYPE_FIXED32: wire_format.WIRETYPE_FIXED32,
+    _FieldDescriptor.TYPE_BOOL: wire_format.WIRETYPE_VARINT,
+    _FieldDescriptor.TYPE_STRING:
+        wire_format.WIRETYPE_LENGTH_DELIMITED,
+    _FieldDescriptor.TYPE_GROUP: wire_format.WIRETYPE_START_GROUP,
+    _FieldDescriptor.TYPE_MESSAGE:
+        wire_format.WIRETYPE_LENGTH_DELIMITED,
+    _FieldDescriptor.TYPE_BYTES:
+        wire_format.WIRETYPE_LENGTH_DELIMITED,
+    _FieldDescriptor.TYPE_UINT32: wire_format.WIRETYPE_VARINT,
+    _FieldDescriptor.TYPE_ENUM: wire_format.WIRETYPE_VARINT,
+    _FieldDescriptor.TYPE_SFIXED32: wire_format.WIRETYPE_FIXED32,
+    _FieldDescriptor.TYPE_SFIXED64: wire_format.WIRETYPE_FIXED64,
+    _FieldDescriptor.TYPE_SINT32: wire_format.WIRETYPE_VARINT,
+    _FieldDescriptor.TYPE_SINT64: wire_format.WIRETYPE_VARINT,
+}
diff --git a/lark_channel/ws/pb/google/protobuf/internal/well_known_types.py b/lark_channel/ws/pb/google/protobuf/internal/well_known_types.py
new file mode 100644
index 0000000..80dae42
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/internal/well_known_types.py
@@ -0,0 +1,879 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+# https://developers.google.com/protocol-buffers/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""Contains well known classes.
+
+This files defines well known classes which need extra maintenance including:
+  - Any
+  - Duration
+  - FieldMask
+  - Struct
+  - Timestamp
+"""
+
+__author__ = 'jieluo@google.com (Jie Luo)'
+
+import calendar
+import collections.abc
+import datetime
+
+from lark_channel.ws.pb.google.protobuf.descriptor import FieldDescriptor
+
+_TIMESTAMPFOMAT = '%Y-%m-%dT%H:%M:%S'
+_NANOS_PER_SECOND = 1000000000
+_NANOS_PER_MILLISECOND = 1000000
+_NANOS_PER_MICROSECOND = 1000
+_MILLIS_PER_SECOND = 1000
+_MICROS_PER_SECOND = 1000000
+_SECONDS_PER_DAY = 24 * 3600
+_DURATION_SECONDS_MAX = 315576000000
+
+
+class Any(object):
+    """Class for Any Message type."""
+
+    __slots__ = ()
+
+    def Pack(self, msg, type_url_prefix='type.googleapis.com/',
+             deterministic=None):
+        """Packs the specified message into current Any message."""
+        if len(type_url_prefix) < 1 or type_url_prefix[-1] != '/':
+            self.type_url = '%s/%s' % (type_url_prefix, msg.DESCRIPTOR.full_name)
+        else:
+            self.type_url = '%s%s' % (type_url_prefix, msg.DESCRIPTOR.full_name)
+        self.value = msg.SerializeToString(deterministic=deterministic)
+
+    def Unpack(self, msg):
+        """Unpacks the current Any message into specified message."""
+        descriptor = msg.DESCRIPTOR
+        if not self.Is(descriptor):
+            return False
+        msg.ParseFromString(self.value)
+        return True
+
+    def TypeName(self):
+        """Returns the protobuf type name of the inner message."""
+        # Only last part is to be used: b/25630112
+        return self.type_url.split('/')[-1]
+
+    def Is(self, descriptor):
+        """Checks if this Any represents the given protobuf type."""
+        return '/' in self.type_url and self.TypeName() == descriptor.full_name
+
+
+_EPOCH_DATETIME_NAIVE = datetime.datetime.utcfromtimestamp(0)
+_EPOCH_DATETIME_AWARE = datetime.datetime.fromtimestamp(
+    0, tz=datetime.timezone.utc)
+
+
+class Timestamp(object):
+    """Class for Timestamp message type."""
+
+    __slots__ = ()
+
+    def ToJsonString(self):
+        """Converts Timestamp to RFC 3339 date string format.
+
+        Returns:
+          A string converted from timestamp. The string is always Z-normalized
+          and uses 3, 6 or 9 fractional digits as required to represent the
+          exact time. Example of the return format: '1972-01-01T10:00:20.021Z'
+        """
+        nanos = self.nanos % _NANOS_PER_SECOND
+        total_sec = self.seconds + (self.nanos - nanos) // _NANOS_PER_SECOND
+        seconds = total_sec % _SECONDS_PER_DAY
+        days = (total_sec - seconds) // _SECONDS_PER_DAY
+        dt = datetime.datetime(1970, 1, 1) + datetime.timedelta(days, seconds)
+
+        result = dt.isoformat()
+        if (nanos % 1e9) == 0:
+            # If there are 0 fractional digits, the fractional
+            # point '.' should be omitted when serializing.
+            return result + 'Z'
+        if (nanos % 1e6) == 0:
+            # Serialize 3 fractional digits.
+            return result + '.%03dZ' % (nanos / 1e6)
+        if (nanos % 1e3) == 0:
+            # Serialize 6 fractional digits.
+            return result + '.%06dZ' % (nanos / 1e3)
+        # Serialize 9 fractional digits.
+        return result + '.%09dZ' % nanos
+
+    def FromJsonString(self, value):
+        """Parse a RFC 3339 date string format to Timestamp.
+
+        Args:
+          value: A date string. Any fractional digits (or none) and any offset are
+              accepted as long as they fit into nano-seconds precision.
+              Example of accepted format: '1972-01-01T10:00:20.021-05:00'
+
+        Raises:
+          ValueError: On parsing problems.
+        """
+        if not isinstance(value, str):
+            raise ValueError('Timestamp JSON value not a string: {!r}'.format(value))
+        timezone_offset = value.find('Z')
+        if timezone_offset == -1:
+            timezone_offset = value.find('+')
+        if timezone_offset == -1:
+            timezone_offset = value.rfind('-')
+        if timezone_offset == -1:
+            raise ValueError(
+                'Failed to parse timestamp: missing valid timezone offset.')
+        time_value = value[0:timezone_offset]
+        # Parse datetime and nanos.
+        point_position = time_value.find('.')
+        if point_position == -1:
+            second_value = time_value
+            nano_value = ''
+        else:
+            second_value = time_value[:point_position]
+            nano_value = time_value[point_position + 1:]
+        if 't' in second_value:
+            raise ValueError(
+                'time data \'{0}\' does not match format \'%Y-%m-%dT%H:%M:%S\', '
+                'lowercase \'t\' is not accepted'.format(second_value))
+        date_object = datetime.datetime.strptime(second_value, _TIMESTAMPFOMAT)
+        td = date_object - datetime.datetime(1970, 1, 1)
+        seconds = td.seconds + td.days * _SECONDS_PER_DAY
+        if len(nano_value) > 9:
+            raise ValueError(
+                'Failed to parse Timestamp: nanos {0} more than '
+                '9 fractional digits.'.format(nano_value))
+        if nano_value:
+            nanos = round(float('0.' + nano_value) * 1e9)
+        else:
+            nanos = 0
+        # Parse timezone offsets.
+        if value[timezone_offset] == 'Z':
+            if len(value) != timezone_offset + 1:
+                raise ValueError('Failed to parse timestamp: invalid trailing'
+                                 ' data {0}.'.format(value))
+        else:
+            timezone = value[timezone_offset:]
+            pos = timezone.find(':')
+            if pos == -1:
+                raise ValueError(
+                    'Invalid timezone offset value: {0}.'.format(timezone))
+            if timezone[0] == '+':
+                seconds -= (int(timezone[1:pos]) * 60 + int(timezone[pos + 1:])) * 60
+            else:
+                seconds += (int(timezone[1:pos]) * 60 + int(timezone[pos + 1:])) * 60
+        # Set seconds and nanos
+        self.seconds = int(seconds)
+        self.nanos = int(nanos)
+
+    def GetCurrentTime(self):
+        """Get the current UTC into Timestamp."""
+        self.FromDatetime(datetime.datetime.utcnow())
+
+    def ToNanoseconds(self):
+        """Converts Timestamp to nanoseconds since epoch."""
+        return self.seconds * _NANOS_PER_SECOND + self.nanos
+
+    def ToMicroseconds(self):
+        """Converts Timestamp to microseconds since epoch."""
+        return (self.seconds * _MICROS_PER_SECOND +
+                self.nanos // _NANOS_PER_MICROSECOND)
+
+    def ToMilliseconds(self):
+        """Converts Timestamp to milliseconds since epoch."""
+        return (self.seconds * _MILLIS_PER_SECOND +
+                self.nanos // _NANOS_PER_MILLISECOND)
+
+    def ToSeconds(self):
+        """Converts Timestamp to seconds since epoch."""
+        return self.seconds
+
+    def FromNanoseconds(self, nanos):
+        """Converts nanoseconds since epoch to Timestamp."""
+        self.seconds = nanos // _NANOS_PER_SECOND
+        self.nanos = nanos % _NANOS_PER_SECOND
+
+    def FromMicroseconds(self, micros):
+        """Converts microseconds since epoch to Timestamp."""
+        self.seconds = micros // _MICROS_PER_SECOND
+        self.nanos = (micros % _MICROS_PER_SECOND) * _NANOS_PER_MICROSECOND
+
+    def FromMilliseconds(self, millis):
+        """Converts milliseconds since epoch to Timestamp."""
+        self.seconds = millis // _MILLIS_PER_SECOND
+        self.nanos = (millis % _MILLIS_PER_SECOND) * _NANOS_PER_MILLISECOND
+
+    def FromSeconds(self, seconds):
+        """Converts seconds since epoch to Timestamp."""
+        self.seconds = seconds
+        self.nanos = 0
+
+    def ToDatetime(self, tzinfo=None):
+        """Converts Timestamp to a datetime.
+
+        Args:
+          tzinfo: A datetime.tzinfo subclass; defaults to None.
+
+        Returns:
+          If tzinfo is None, returns a timezone-naive UTC datetime (with no timezone
+          information, i.e. not aware that it's UTC).
+
+          Otherwise, returns a timezone-aware datetime in the input timezone.
+        """
+        delta = datetime.timedelta(
+            seconds=self.seconds,
+            microseconds=_RoundTowardZero(self.nanos, _NANOS_PER_MICROSECOND))
+        if tzinfo is None:
+            return _EPOCH_DATETIME_NAIVE + delta
+        else:
+            return _EPOCH_DATETIME_AWARE.astimezone(tzinfo) + delta
+
+    def FromDatetime(self, dt):
+        """Converts datetime to Timestamp.
+
+        Args:
+          dt: A datetime. If it's timezone-naive, it's assumed to be in UTC.
+        """
+        # Using this guide: http://wiki.python.org/moin/WorkingWithTime
+        # And this conversion guide: http://docs.python.org/library/time.html
+
+        # Turn the date parameter into a tuple (struct_time) that can then be
+        # manipulated into a long value of seconds.  During the conversion from
+        # struct_time to long, the source date in UTC, and so it follows that the
+        # correct transformation is calendar.timegm()
+        self.seconds = calendar.timegm(dt.utctimetuple())
+        self.nanos = dt.microsecond * _NANOS_PER_MICROSECOND
+
+
+class Duration(object):
+    """Class for Duration message type."""
+
+    __slots__ = ()
+
+    def ToJsonString(self):
+        """Converts Duration to string format.
+
+        Returns:
+          A string converted from self. The string format will contains
+          3, 6, or 9 fractional digits depending on the precision required to
+          represent the exact Duration value. For example: "1s", "1.010s",
+          "1.000000100s", "-3.100s"
+        """
+        _CheckDurationValid(self.seconds, self.nanos)
+        if self.seconds < 0 or self.nanos < 0:
+            result = '-'
+            seconds = - self.seconds + int((0 - self.nanos) // 1e9)
+            nanos = (0 - self.nanos) % 1e9
+        else:
+            result = ''
+            seconds = self.seconds + int(self.nanos // 1e9)
+            nanos = self.nanos % 1e9
+        result += '%d' % seconds
+        if (nanos % 1e9) == 0:
+            # If there are 0 fractional digits, the fractional
+            # point '.' should be omitted when serializing.
+            return result + 's'
+        if (nanos % 1e6) == 0:
+            # Serialize 3 fractional digits.
+            return result + '.%03ds' % (nanos / 1e6)
+        if (nanos % 1e3) == 0:
+            # Serialize 6 fractional digits.
+            return result + '.%06ds' % (nanos / 1e3)
+        # Serialize 9 fractional digits.
+        return result + '.%09ds' % nanos
+
+    def FromJsonString(self, value):
+        """Converts a string to Duration.
+
+        Args:
+          value: A string to be converted. The string must end with 's'. Any
+              fractional digits (or none) are accepted as long as they fit into
+              precision. For example: "1s", "1.01s", "1.0000001s", "-3.100s
+
+        Raises:
+          ValueError: On parsing problems.
+        """
+        if not isinstance(value, str):
+            raise ValueError('Duration JSON value not a string: {!r}'.format(value))
+        if len(value) < 1 or value[-1] != 's':
+            raise ValueError(
+                'Duration must end with letter "s": {0}.'.format(value))
+        try:
+            pos = value.find('.')
+            if pos == -1:
+                seconds = int(value[:-1])
+                nanos = 0
+            else:
+                seconds = int(value[:pos])
+                if value[0] == '-':
+                    nanos = int(round(float('-0{0}'.format(value[pos: -1])) * 1e9))
+                else:
+                    nanos = int(round(float('0{0}'.format(value[pos: -1])) * 1e9))
+            _CheckDurationValid(seconds, nanos)
+            self.seconds = seconds
+            self.nanos = nanos
+        except ValueError as e:
+            raise ValueError(
+                'Couldn\'t parse duration: {0} : {1}.'.format(value, e))
+
+    def ToNanoseconds(self):
+        """Converts a Duration to nanoseconds."""
+        return self.seconds * _NANOS_PER_SECOND + self.nanos
+
+    def ToMicroseconds(self):
+        """Converts a Duration to microseconds."""
+        micros = _RoundTowardZero(self.nanos, _NANOS_PER_MICROSECOND)
+        return self.seconds * _MICROS_PER_SECOND + micros
+
+    def ToMilliseconds(self):
+        """Converts a Duration to milliseconds."""
+        millis = _RoundTowardZero(self.nanos, _NANOS_PER_MILLISECOND)
+        return self.seconds * _MILLIS_PER_SECOND + millis
+
+    def ToSeconds(self):
+        """Converts a Duration to seconds."""
+        return self.seconds
+
+    def FromNanoseconds(self, nanos):
+        """Converts nanoseconds to Duration."""
+        self._NormalizeDuration(nanos // _NANOS_PER_SECOND,
+                                nanos % _NANOS_PER_SECOND)
+
+    def FromMicroseconds(self, micros):
+        """Converts microseconds to Duration."""
+        self._NormalizeDuration(
+            micros // _MICROS_PER_SECOND,
+            (micros % _MICROS_PER_SECOND) * _NANOS_PER_MICROSECOND)
+
+    def FromMilliseconds(self, millis):
+        """Converts milliseconds to Duration."""
+        self._NormalizeDuration(
+            millis // _MILLIS_PER_SECOND,
+            (millis % _MILLIS_PER_SECOND) * _NANOS_PER_MILLISECOND)
+
+    def FromSeconds(self, seconds):
+        """Converts seconds to Duration."""
+        self.seconds = seconds
+        self.nanos = 0
+
+    def ToTimedelta(self):
+        """Converts Duration to timedelta."""
+        return datetime.timedelta(
+            seconds=self.seconds, microseconds=_RoundTowardZero(
+                self.nanos, _NANOS_PER_MICROSECOND))
+
+    def FromTimedelta(self, td):
+        """Converts timedelta to Duration."""
+        self._NormalizeDuration(td.seconds + td.days * _SECONDS_PER_DAY,
+                                td.microseconds * _NANOS_PER_MICROSECOND)
+
+    def _NormalizeDuration(self, seconds, nanos):
+        """Set Duration by seconds and nanos."""
+        # Force nanos to be negative if the duration is negative.
+        if seconds < 0 and nanos > 0:
+            seconds += 1
+            nanos -= _NANOS_PER_SECOND
+        self.seconds = seconds
+        self.nanos = nanos
+
+
+def _CheckDurationValid(seconds, nanos):
+    if seconds < -_DURATION_SECONDS_MAX or seconds > _DURATION_SECONDS_MAX:
+        raise ValueError(
+            'Duration is not valid: Seconds {0} must be in range '
+            '[-315576000000, 315576000000].'.format(seconds))
+    if nanos <= -_NANOS_PER_SECOND or nanos >= _NANOS_PER_SECOND:
+        raise ValueError(
+            'Duration is not valid: Nanos {0} must be in range '
+            '[-999999999, 999999999].'.format(nanos))
+    if (nanos < 0 and seconds > 0) or (nanos > 0 and seconds < 0):
+        raise ValueError(
+            'Duration is not valid: Sign mismatch.')
+
+
+def _RoundTowardZero(value, divider):
+    """Truncates the remainder part after division."""
+    # For some languages, the sign of the remainder is implementation
+    # dependent if any of the operands is negative. Here we enforce
+    # "rounded toward zero" semantics. For example, for (-5) / 2 an
+    # implementation may give -3 as the result with the remainder being
+    # 1. This function ensures we always return -2 (closer to zero).
+    result = value // divider
+    remainder = value % divider
+    if result < 0 and remainder > 0:
+        return result + 1
+    else:
+        return result
+
+
+class FieldMask(object):
+    """Class for FieldMask message type."""
+
+    __slots__ = ()
+
+    def ToJsonString(self):
+        """Converts FieldMask to string according to proto3 JSON spec."""
+        camelcase_paths = []
+        for path in self.paths:
+            camelcase_paths.append(_SnakeCaseToCamelCase(path))
+        return ','.join(camelcase_paths)
+
+    def FromJsonString(self, value):
+        """Converts string to FieldMask according to proto3 JSON spec."""
+        if not isinstance(value, str):
+            raise ValueError('FieldMask JSON value not a string: {!r}'.format(value))
+        self.Clear()
+        if value:
+            for path in value.split(','):
+                self.paths.append(_CamelCaseToSnakeCase(path))
+
+    def IsValidForDescriptor(self, message_descriptor):
+        """Checks whether the FieldMask is valid for Message Descriptor."""
+        for path in self.paths:
+            if not _IsValidPath(message_descriptor, path):
+                return False
+        return True
+
+    def AllFieldsFromDescriptor(self, message_descriptor):
+        """Gets all direct fields of Message Descriptor to FieldMask."""
+        self.Clear()
+        for field in message_descriptor.fields:
+            self.paths.append(field.name)
+
+    def CanonicalFormFromMask(self, mask):
+        """Converts a FieldMask to the canonical form.
+
+        Removes paths that are covered by another path. For example,
+        "foo.bar" is covered by "foo" and will be removed if "foo"
+        is also in the FieldMask. Then sorts all paths in alphabetical order.
+
+        Args:
+          mask: The original FieldMask to be converted.
+        """
+        tree = _FieldMaskTree(mask)
+        tree.ToFieldMask(self)
+
+    def Union(self, mask1, mask2):
+        """Merges mask1 and mask2 into this FieldMask."""
+        _CheckFieldMaskMessage(mask1)
+        _CheckFieldMaskMessage(mask2)
+        tree = _FieldMaskTree(mask1)
+        tree.MergeFromFieldMask(mask2)
+        tree.ToFieldMask(self)
+
+    def Intersect(self, mask1, mask2):
+        """Intersects mask1 and mask2 into this FieldMask."""
+        _CheckFieldMaskMessage(mask1)
+        _CheckFieldMaskMessage(mask2)
+        tree = _FieldMaskTree(mask1)
+        intersection = _FieldMaskTree()
+        for path in mask2.paths:
+            tree.IntersectPath(path, intersection)
+        intersection.ToFieldMask(self)
+
+    def MergeMessage(
+            self, source, destination,
+            replace_message_field=False, replace_repeated_field=False):
+        """Merges fields specified in FieldMask from source to destination.
+
+        Args:
+          source: Source message.
+          destination: The destination message to be merged into.
+          replace_message_field: Replace message field if True. Merge message
+              field if False.
+          replace_repeated_field: Replace repeated field if True. Append
+              elements of repeated field if False.
+        """
+        tree = _FieldMaskTree(self)
+        tree.MergeMessage(
+            source, destination, replace_message_field, replace_repeated_field)
+
+
+def _IsValidPath(message_descriptor, path):
+    """Checks whether the path is valid for Message Descriptor."""
+    parts = path.split('.')
+    last = parts.pop()
+    for name in parts:
+        field = message_descriptor.fields_by_name.get(name)
+        if (field is None or
+                field.label == FieldDescriptor.LABEL_REPEATED or
+                field.type != FieldDescriptor.TYPE_MESSAGE):
+            return False
+        message_descriptor = field.message_type
+    return last in message_descriptor.fields_by_name
+
+
+def _CheckFieldMaskMessage(message):
+    """Raises ValueError if message is not a FieldMask."""
+    message_descriptor = message.DESCRIPTOR
+    if (message_descriptor.name != 'FieldMask' or
+            message_descriptor.file.name != 'google/protobuf/field_mask.proto'):
+        raise ValueError('Message {0} is not a FieldMask.'.format(
+            message_descriptor.full_name))
+
+
+def _SnakeCaseToCamelCase(path_name):
+    """Converts a path name from snake_case to camelCase."""
+    result = []
+    after_underscore = False
+    for c in path_name:
+        if c.isupper():
+            raise ValueError(
+                'Fail to print FieldMask to Json string: Path name '
+                '{0} must not contain uppercase letters.'.format(path_name))
+        if after_underscore:
+            if c.islower():
+                result.append(c.upper())
+                after_underscore = False
+            else:
+                raise ValueError(
+                    'Fail to print FieldMask to Json string: The '
+                    'character after a "_" must be a lowercase letter '
+                    'in path name {0}.'.format(path_name))
+        elif c == '_':
+            after_underscore = True
+        else:
+            result += c
+
+    if after_underscore:
+        raise ValueError('Fail to print FieldMask to Json string: Trailing "_" '
+                         'in path name {0}.'.format(path_name))
+    return ''.join(result)
+
+
+def _CamelCaseToSnakeCase(path_name):
+    """Converts a field name from camelCase to snake_case."""
+    result = []
+    for c in path_name:
+        if c == '_':
+            raise ValueError('Fail to parse FieldMask: Path name '
+                             '{0} must not contain "_"s.'.format(path_name))
+        if c.isupper():
+            result += '_'
+            result += c.lower()
+        else:
+            result += c
+    return ''.join(result)
+
+
+class _FieldMaskTree(object):
+    """Represents a FieldMask in a tree structure.
+
+    For example, given a FieldMask "foo.bar,foo.baz,bar.baz",
+    the FieldMaskTree will be:
+        [_root] -+- foo -+- bar
+              |       |
+              |       +- baz
+              |
+              +- bar --- baz
+    In the tree, each leaf node represents a field path.
+    """
+
+    __slots__ = ('_root',)
+
+    def __init__(self, field_mask=None):
+        """Initializes the tree by FieldMask."""
+        self._root = {}
+        if field_mask:
+            self.MergeFromFieldMask(field_mask)
+
+    def MergeFromFieldMask(self, field_mask):
+        """Merges a FieldMask to the tree."""
+        for path in field_mask.paths:
+            self.AddPath(path)
+
+    def AddPath(self, path):
+        """Adds a field path into the tree.
+
+        If the field path to add is a sub-path of an existing field path
+        in the tree (i.e., a leaf node), it means the tree already matches
+        the given path so nothing will be added to the tree. If the path
+        matches an existing non-leaf node in the tree, that non-leaf node
+        will be turned into a leaf node with all its children removed because
+        the path matches all the node's children. Otherwise, a new path will
+        be added.
+
+        Args:
+          path: The field path to add.
+        """
+        node = self._root
+        for name in path.split('.'):
+            if name not in node:
+                node[name] = {}
+            elif not node[name]:
+                # Pre-existing empty node implies we already have this entire tree.
+                return
+            node = node[name]
+        # Remove any sub-trees we might have had.
+        node.clear()
+
+    def ToFieldMask(self, field_mask):
+        """Converts the tree to a FieldMask."""
+        field_mask.Clear()
+        _AddFieldPaths(self._root, '', field_mask)
+
+    def IntersectPath(self, path, intersection):
+        """Calculates the intersection part of a field path with this tree.
+
+        Args:
+          path: The field path to calculates.
+          intersection: The out tree to record the intersection part.
+        """
+        node = self._root
+        for name in path.split('.'):
+            if name not in node:
+                return
+            elif not node[name]:
+                intersection.AddPath(path)
+                return
+            node = node[name]
+        intersection.AddLeafNodes(path, node)
+
+    def AddLeafNodes(self, prefix, node):
+        """Adds leaf nodes begin with prefix to this tree."""
+        if not node:
+            self.AddPath(prefix)
+        for name in node:
+            child_path = prefix + '.' + name
+            self.AddLeafNodes(child_path, node[name])
+
+    def MergeMessage(
+            self, source, destination,
+            replace_message, replace_repeated):
+        """Merge all fields specified by this tree from source to destination."""
+        _MergeMessage(
+            self._root, source, destination, replace_message, replace_repeated)
+
+
+def _StrConvert(value):
+    """Converts value to str if it is not."""
+    # This file is imported by c extension and some methods like ClearField
+    # requires string for the field name. py2/py3 has different text
+    # type and may use unicode.
+    if not isinstance(value, str):
+        return value.encode('utf-8')
+    return value
+
+
+def _MergeMessage(
+        node, source, destination, replace_message, replace_repeated):
+    """Merge all fields specified by a sub-tree from source to destination."""
+    source_descriptor = source.DESCRIPTOR
+    for name in node:
+        child = node[name]
+        field = source_descriptor.fields_by_name[name]
+        if field is None:
+            raise ValueError('Error: Can\'t find field {0} in message {1}.'.format(
+                name, source_descriptor.full_name))
+        if child:
+            # Sub-paths are only allowed for singular message fields.
+            if (field.label == FieldDescriptor.LABEL_REPEATED or
+                    field.cpp_type != FieldDescriptor.CPPTYPE_MESSAGE):
+                raise ValueError('Error: Field {0} in message {1} is not a singular '
+                                 'message field and cannot have sub-fields.'.format(
+                    name, source_descriptor.full_name))
+            if source.HasField(name):
+                _MergeMessage(
+                    child, getattr(source, name), getattr(destination, name),
+                    replace_message, replace_repeated)
+            continue
+        if field.label == FieldDescriptor.LABEL_REPEATED:
+            if replace_repeated:
+                destination.ClearField(_StrConvert(name))
+            repeated_source = getattr(source, name)
+            repeated_destination = getattr(destination, name)
+            repeated_destination.MergeFrom(repeated_source)
+        else:
+            if field.cpp_type == FieldDescriptor.CPPTYPE_MESSAGE:
+                if replace_message:
+                    destination.ClearField(_StrConvert(name))
+                if source.HasField(name):
+                    getattr(destination, name).MergeFrom(getattr(source, name))
+            else:
+                setattr(destination, name, getattr(source, name))
+
+
+def _AddFieldPaths(node, prefix, field_mask):
+    """Adds the field paths descended from node to field_mask."""
+    if not node and prefix:
+        field_mask.paths.append(prefix)
+        return
+    for name in sorted(node):
+        if prefix:
+            child_path = prefix + '.' + name
+        else:
+            child_path = name
+        _AddFieldPaths(node[name], child_path, field_mask)
+
+
+def _SetStructValue(struct_value, value):
+    if value is None:
+        struct_value.null_value = 0
+    elif isinstance(value, bool):
+        # Note: this check must come before the number check because in Python
+        # True and False are also considered numbers.
+        struct_value.bool_value = value
+    elif isinstance(value, str):
+        struct_value.string_value = value
+    elif isinstance(value, (int, float)):
+        struct_value.number_value = value
+    elif isinstance(value, (dict, Struct)):
+        struct_value.struct_value.Clear()
+        struct_value.struct_value.update(value)
+    elif isinstance(value, (list, ListValue)):
+        struct_value.list_value.Clear()
+        struct_value.list_value.extend(value)
+    else:
+        raise ValueError('Unexpected type')
+
+
+def _GetStructValue(struct_value):
+    which = struct_value.WhichOneof('kind')
+    if which == 'struct_value':
+        return struct_value.struct_value
+    elif which == 'null_value':
+        return None
+    elif which == 'number_value':
+        return struct_value.number_value
+    elif which == 'string_value':
+        return struct_value.string_value
+    elif which == 'bool_value':
+        return struct_value.bool_value
+    elif which == 'list_value':
+        return struct_value.list_value
+    elif which is None:
+        raise ValueError('Value not set')
+
+
+class Struct(object):
+    """Class for Struct message type."""
+
+    __slots__ = ()
+
+    def __getitem__(self, key):
+        return _GetStructValue(self.fields[key])
+
+    def __contains__(self, item):
+        return item in self.fields
+
+    def __setitem__(self, key, value):
+        _SetStructValue(self.fields[key], value)
+
+    def __delitem__(self, key):
+        del self.fields[key]
+
+    def __len__(self):
+        return len(self.fields)
+
+    def __iter__(self):
+        return iter(self.fields)
+
+    def keys(self):  # pylint: disable=invalid-name
+        return self.fields.keys()
+
+    def values(self):  # pylint: disable=invalid-name
+        return [self[key] for key in self]
+
+    def items(self):  # pylint: disable=invalid-name
+        return [(key, self[key]) for key in self]
+
+    def get_or_create_list(self, key):
+        """Returns a list for this key, creating if it didn't exist already."""
+        if not self.fields[key].HasField('list_value'):
+            # Clear will mark list_value modified which will indeed create a list.
+            self.fields[key].list_value.Clear()
+        return self.fields[key].list_value
+
+    def get_or_create_struct(self, key):
+        """Returns a struct for this key, creating if it didn't exist already."""
+        if not self.fields[key].HasField('struct_value'):
+            # Clear will mark struct_value modified which will indeed create a struct.
+            self.fields[key].struct_value.Clear()
+        return self.fields[key].struct_value
+
+    def update(self, dictionary):  # pylint: disable=invalid-name
+        for key, value in dictionary.items():
+            _SetStructValue(self.fields[key], value)
+
+
+collections.abc.MutableMapping.register(Struct)
+
+
+class ListValue(object):
+    """Class for ListValue message type."""
+
+    __slots__ = ()
+
+    def __len__(self):
+        return len(self.values)
+
+    def append(self, value):
+        _SetStructValue(self.values.add(), value)
+
+    def extend(self, elem_seq):
+        for value in elem_seq:
+            self.append(value)
+
+    def __getitem__(self, index):
+        """Retrieves item by the specified index."""
+        return _GetStructValue(self.values.__getitem__(index))
+
+    def __setitem__(self, index, value):
+        _SetStructValue(self.values.__getitem__(index), value)
+
+    def __delitem__(self, key):
+        del self.values[key]
+
+    def items(self):
+        for i in range(len(self)):
+            yield self[i]
+
+    def add_struct(self):
+        """Appends and returns a struct value as the next value in the list."""
+        struct_value = self.values.add().struct_value
+        # Clear will mark struct_value modified which will indeed create a struct.
+        struct_value.Clear()
+        return struct_value
+
+    def add_list(self):
+        """Appends and returns a list value as the next value in the list."""
+        list_value = self.values.add().list_value
+        # Clear will mark list_value modified which will indeed create a list.
+        list_value.Clear()
+        return list_value
+
+
+collections.abc.MutableSequence.register(ListValue)
+
+WKTBASES = {
+    'google.protobuf.Any': Any,
+    'google.protobuf.Duration': Duration,
+    'google.protobuf.FieldMask': FieldMask,
+    'google.protobuf.ListValue': ListValue,
+    'google.protobuf.Struct': Struct,
+    'google.protobuf.Timestamp': Timestamp,
+}
diff --git a/lark_channel/ws/pb/google/protobuf/internal/wire_format.py b/lark_channel/ws/pb/google/protobuf/internal/wire_format.py
new file mode 100644
index 0000000..b0c69b4
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/internal/wire_format.py
@@ -0,0 +1,264 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+# https://developers.google.com/protocol-buffers/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""Constants and static functions to support protocol buffer wire format."""
+
+__author__ = 'robinson@google.com (Will Robinson)'
+
+import struct
+from lark_channel.ws.pb.google.protobuf import descriptor
+from lark_channel.ws.pb.google.protobuf import message
+
+TAG_TYPE_BITS = 3  # Number of bits used to hold type info in a proto tag.
+TAG_TYPE_MASK = (1 << TAG_TYPE_BITS) - 1  # 0x7
+
+# These numbers identify the wire type of a protocol buffer value.
+# We use the least-significant TAG_TYPE_BITS bits of the varint-encoded
+# tag-and-type to store one of these WIRETYPE_* constants.
+# These values must match WireType enum in google/protobuf/wire_format.h.
+WIRETYPE_VARINT = 0
+WIRETYPE_FIXED64 = 1
+WIRETYPE_LENGTH_DELIMITED = 2
+WIRETYPE_START_GROUP = 3
+WIRETYPE_END_GROUP = 4
+WIRETYPE_FIXED32 = 5
+_WIRETYPE_MAX = 5
+
+# Bounds for various integer types.
+INT32_MAX = int((1 << 31) - 1)
+INT32_MIN = int(-(1 << 31))
+UINT32_MAX = (1 << 32) - 1
+
+INT64_MAX = (1 << 63) - 1
+INT64_MIN = -(1 << 63)
+UINT64_MAX = (1 << 64) - 1
+
+# "struct" format strings that will encode/decode the specified formats.
+FORMAT_UINT32_LITTLE_ENDIAN = '<I'
+FORMAT_UINT64_LITTLE_ENDIAN = '<Q'
+FORMAT_FLOAT_LITTLE_ENDIAN = '<f'
+FORMAT_DOUBLE_LITTLE_ENDIAN = '<d'
+
+# We'll have to provide alternate implementations of AppendLittleEndian*() on
+# any architectures where these checks fail.
+if struct.calcsize(FORMAT_UINT32_LITTLE_ENDIAN) != 4:
+    raise AssertionError('Format "I" is not a 32-bit number.')
+if struct.calcsize(FORMAT_UINT64_LITTLE_ENDIAN) != 8:
+    raise AssertionError('Format "Q" is not a 64-bit number.')
+
+
+def PackTag(field_number, wire_type):
+    """Returns an unsigned 32-bit integer that encodes the field number and
+    wire type information in standard protocol message wire format.
+
+    Args:
+      field_number: Expected to be an integer in the range [1, 1 << 29)
+      wire_type: One of the WIRETYPE_* constants.
+    """
+    if not 0 <= wire_type <= _WIRETYPE_MAX:
+        raise message.EncodeError('Unknown wire type: %d' % wire_type)
+    return (field_number << TAG_TYPE_BITS) | wire_type
+
+
+def UnpackTag(tag):
+    """The inverse of PackTag().  Given an unsigned 32-bit number,
+    returns a (field_number, wire_type) tuple.
+    """
+    return (tag >> TAG_TYPE_BITS), (tag & TAG_TYPE_MASK)
+
+
+def ZigZagEncode(value):
+    """ZigZag Transform:  Encodes signed integers so that they can be
+    effectively used with varint encoding.  See wire_format.h for
+    more details.
+    """
+    if value >= 0:
+        return value << 1
+    return (value << 1) ^ (~0)
+
+
+def ZigZagDecode(value):
+    """Inverse of ZigZagEncode()."""
+    if not value & 0x1:
+        return value >> 1
+    return (value >> 1) ^ (~0)
+
+
+# The *ByteSize() functions below return the number of bytes required to
+# serialize "field number + type" information and then serialize the value.
+
+
+def Int32ByteSize(field_number, int32):
+    return Int64ByteSize(field_number, int32)
+
+
+def Int32ByteSizeNoTag(int32):
+    return _VarUInt64ByteSizeNoTag(0xffffffffffffffff & int32)
+
+
+def Int64ByteSize(field_number, int64):
+    # Have to convert to uint before calling UInt64ByteSize().
+    return UInt64ByteSize(field_number, 0xffffffffffffffff & int64)
+
+
+def UInt32ByteSize(field_number, uint32):
+    return UInt64ByteSize(field_number, uint32)
+
+
+def UInt64ByteSize(field_number, uint64):
+    return TagByteSize(field_number) + _VarUInt64ByteSizeNoTag(uint64)
+
+
+def SInt32ByteSize(field_number, int32):
+    return UInt32ByteSize(field_number, ZigZagEncode(int32))
+
+
+def SInt64ByteSize(field_number, int64):
+    return UInt64ByteSize(field_number, ZigZagEncode(int64))
+
+
+def Fixed32ByteSize(field_number, fixed32):
+    return TagByteSize(field_number) + 4
+
+
+def Fixed64ByteSize(field_number, fixed64):
+    return TagByteSize(field_number) + 8
+
+
+def SFixed32ByteSize(field_number, sfixed32):
+    return TagByteSize(field_number) + 4
+
+
+def SFixed64ByteSize(field_number, sfixed64):
+    return TagByteSize(field_number) + 8
+
+
+def FloatByteSize(field_number, flt):
+    return TagByteSize(field_number) + 4
+
+
+def DoubleByteSize(field_number, double):
+    return TagByteSize(field_number) + 8
+
+
+def BoolByteSize(field_number, b):
+    return TagByteSize(field_number) + 1
+
+
+def EnumByteSize(field_number, enum):
+    return UInt32ByteSize(field_number, enum)
+
+
+def StringByteSize(field_number, string):
+    return BytesByteSize(field_number, string.encode('utf-8'))
+
+
+def BytesByteSize(field_number, b):
+    return (TagByteSize(field_number)
+            + _VarUInt64ByteSizeNoTag(len(b))
+            + len(b))
+
+
+def GroupByteSize(field_number, message):
+    return (2 * TagByteSize(field_number)  # START and END group.
+            + message.ByteSize())
+
+
+def MessageByteSize(field_number, message):
+    return (TagByteSize(field_number)
+            + _VarUInt64ByteSizeNoTag(message.ByteSize())
+            + message.ByteSize())
+
+
+def MessageSetItemByteSize(field_number, msg):
+    # First compute the sizes of the tags.
+    # There are 2 tags for the beginning and ending of the repeated group, that
+    # is field number 1, one with field number 2 (type_id) and one with field
+    # number 3 (message).
+    total_size = (2 * TagByteSize(1) + TagByteSize(2) + TagByteSize(3))
+
+    # Add the number of bytes for type_id.
+    total_size += _VarUInt64ByteSizeNoTag(field_number)
+
+    message_size = msg.ByteSize()
+
+    # The number of bytes for encoding the length of the message.
+    total_size += _VarUInt64ByteSizeNoTag(message_size)
+
+    # The size of the message.
+    total_size += message_size
+    return total_size
+
+
+def TagByteSize(field_number):
+    """Returns the bytes required to serialize a tag with this field number."""
+    # Just pass in type 0, since the type won't affect the tag+type size.
+    return _VarUInt64ByteSizeNoTag(PackTag(field_number, 0))
+
+
+# Private helper function for the *ByteSize() functions above.
+
+def _VarUInt64ByteSizeNoTag(uint64):
+    """Returns the number of bytes required to serialize a single varint
+    using boundary value comparisons. (unrolled loop optimization -WPierce)
+    uint64 must be unsigned.
+    """
+    if uint64 <= 0x7f: return 1
+    if uint64 <= 0x3fff: return 2
+    if uint64 <= 0x1fffff: return 3
+    if uint64 <= 0xfffffff: return 4
+    if uint64 <= 0x7ffffffff: return 5
+    if uint64 <= 0x3ffffffffff: return 6
+    if uint64 <= 0x1ffffffffffff: return 7
+    if uint64 <= 0xffffffffffffff: return 8
+    if uint64 <= 0x7fffffffffffffff: return 9
+    if uint64 > UINT64_MAX:
+        raise message.EncodeError('Value out of range: %d' % uint64)
+    return 10
+
+
+NON_PACKABLE_TYPES = (
+    descriptor.FieldDescriptor.TYPE_STRING,
+    descriptor.FieldDescriptor.TYPE_GROUP,
+    descriptor.FieldDescriptor.TYPE_MESSAGE,
+    descriptor.FieldDescriptor.TYPE_BYTES
+)
+
+
+def IsTypePackable(field_type):
+    """Return true iff packable = true is valid for fields of this type.
+
+    Args:
+      field_type: a FieldDescriptor::Type value.
+
+    Returns:
+      True iff fields of this type are packable.
+    """
+    return field_type not in NON_PACKABLE_TYPES
diff --git a/lark_channel/ws/pb/google/protobuf/json_format.py b/lark_channel/ws/pb/google/protobuf/json_format.py
new file mode 100644
index 0000000..6f2d352
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/json_format.py
@@ -0,0 +1,911 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+# https://developers.google.com/protocol-buffers/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""Contains routines for printing protocol messages in JSON format.
+
+Simple usage example:
+
+  # Create a proto object and serialize it to a json format string.
+  message = my_proto_pb2.MyMessage(foo='bar')
+  json_string = json_format.MessageToJson(message)
+
+  # Parse a json format string to proto object.
+  message = json_format.Parse(json_string, my_proto_pb2.MyMessage())
+"""
+
+__author__ = 'jieluo@google.com (Jie Luo)'
+
+import base64
+from collections import OrderedDict
+import json
+import math
+from operator import methodcaller
+import re
+import sys
+
+from lark_channel.ws.pb.google.protobuf.internal import type_checkers
+from lark_channel.ws.pb.google.protobuf import descriptor
+from lark_channel.ws.pb.google.protobuf import symbol_database
+
+_TIMESTAMPFOMAT = '%Y-%m-%dT%H:%M:%S'
+_INT_TYPES = frozenset([descriptor.FieldDescriptor.CPPTYPE_INT32,
+                        descriptor.FieldDescriptor.CPPTYPE_UINT32,
+                        descriptor.FieldDescriptor.CPPTYPE_INT64,
+                        descriptor.FieldDescriptor.CPPTYPE_UINT64])
+_INT64_TYPES = frozenset([descriptor.FieldDescriptor.CPPTYPE_INT64,
+                          descriptor.FieldDescriptor.CPPTYPE_UINT64])
+_FLOAT_TYPES = frozenset([descriptor.FieldDescriptor.CPPTYPE_FLOAT,
+                          descriptor.FieldDescriptor.CPPTYPE_DOUBLE])
+_INFINITY = 'Infinity'
+_NEG_INFINITY = '-Infinity'
+_NAN = 'NaN'
+
+_UNPAIRED_SURROGATE_PATTERN = re.compile(
+    u'[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]')
+
+_VALID_EXTENSION_NAME = re.compile(r'\[[a-zA-Z0-9\._]*\]$')
+
+
+class Error(Exception):
+    """Top-level module error for json_format."""
+
+
+class SerializeToJsonError(Error):
+    """Thrown if serialization to JSON fails."""
+
+
+class ParseError(Error):
+    """Thrown in case of parsing error."""
+
+
+def MessageToJson(
+        message,
+        including_default_value_fields=False,
+        preserving_proto_field_name=False,
+        indent=2,
+        sort_keys=False,
+        use_integers_for_enums=False,
+        descriptor_pool=None,
+        float_precision=None,
+        ensure_ascii=True):
+    """Converts protobuf message to JSON format.
+
+    Args:
+      message: The protocol buffers message instance to serialize.
+      including_default_value_fields: If True, singular primitive fields,
+          repeated fields, and map fields will always be serialized.  If
+          False, only serialize non-empty fields.  Singular message fields
+          and oneof fields are not affected by this option.
+      preserving_proto_field_name: If True, use the original proto field
+          names as defined in the .proto file. If False, convert the field
+          names to lowerCamelCase.
+      indent: The JSON object will be pretty-printed with this indent level.
+          An indent level of 0 or negative will only insert newlines.
+      sort_keys: If True, then the output will be sorted by field names.
+      use_integers_for_enums: If true, print integers instead of enum names.
+      descriptor_pool: A Descriptor Pool for resolving types. If None use the
+          default.
+      float_precision: If set, use this to specify float field valid digits.
+      ensure_ascii: If True, strings with non-ASCII characters are escaped.
+          If False, Unicode strings are returned unchanged.
+
+    Returns:
+      A string containing the JSON formatted protocol buffer message.
+    """
+    printer = _Printer(
+        including_default_value_fields,
+        preserving_proto_field_name,
+        use_integers_for_enums,
+        descriptor_pool,
+        float_precision=float_precision)
+    return printer.ToJsonString(message, indent, sort_keys, ensure_ascii)
+
+
+def MessageToDict(
+        message,
+        including_default_value_fields=False,
+        preserving_proto_field_name=False,
+        use_integers_for_enums=False,
+        descriptor_pool=None,
+        float_precision=None):
+    """Converts protobuf message to a dictionary.
+
+    When the dictionary is encoded to JSON, it conforms to proto3 JSON spec.
+
+    Args:
+      message: The protocol buffers message instance to serialize.
+      including_default_value_fields: If True, singular primitive fields,
+          repeated fields, and map fields will always be serialized.  If
+          False, only serialize non-empty fields.  Singular message fields
+          and oneof fields are not affected by this option.
+      preserving_proto_field_name: If True, use the original proto field
+          names as defined in the .proto file. If False, convert the field
+          names to lowerCamelCase.
+      use_integers_for_enums: If true, print integers instead of enum names.
+      descriptor_pool: A Descriptor Pool for resolving types. If None use the
+          default.
+      float_precision: If set, use this to specify float field valid digits.
+
+    Returns:
+      A dict representation of the protocol buffer message.
+    """
+    printer = _Printer(
+        including_default_value_fields,
+        preserving_proto_field_name,
+        use_integers_for_enums,
+        descriptor_pool,
+        float_precision=float_precision)
+    # pylint: disable=protected-access
+    return printer._MessageToJsonObject(message)
+
+
+def _IsMapEntry(field):
+    return (field.type == descriptor.FieldDescriptor.TYPE_MESSAGE and
+            field.message_type.has_options and
+            field.message_type.GetOptions().map_entry)
+
+
+class _Printer(object):
+    """JSON format printer for protocol message."""
+
+    def __init__(
+            self,
+            including_default_value_fields=False,
+            preserving_proto_field_name=False,
+            use_integers_for_enums=False,
+            descriptor_pool=None,
+            float_precision=None):
+        self.including_default_value_fields = including_default_value_fields
+        self.preserving_proto_field_name = preserving_proto_field_name
+        self.use_integers_for_enums = use_integers_for_enums
+        self.descriptor_pool = descriptor_pool
+        if float_precision:
+            self.float_format = '.{}g'.format(float_precision)
+        else:
+            self.float_format = None
+
+    def ToJsonString(self, message, indent, sort_keys, ensure_ascii):
+        js = self._MessageToJsonObject(message)
+        return json.dumps(
+            js, indent=indent, sort_keys=sort_keys, ensure_ascii=ensure_ascii)
+
+    def _MessageToJsonObject(self, message):
+        """Converts message to an object according to Proto3 JSON Specification."""
+        message_descriptor = message.DESCRIPTOR
+        full_name = message_descriptor.full_name
+        if _IsWrapperMessage(message_descriptor):
+            return self._WrapperMessageToJsonObject(message)
+        if full_name in _WKTJSONMETHODS:
+            return methodcaller(_WKTJSONMETHODS[full_name][0], message)(self)
+        js = {}
+        return self._RegularMessageToJsonObject(message, js)
+
+    def _RegularMessageToJsonObject(self, message, js):
+        """Converts normal message according to Proto3 JSON Specification."""
+        fields = message.ListFields()
+
+        try:
+            for field, value in fields:
+                if self.preserving_proto_field_name:
+                    name = field.name
+                else:
+                    name = field.json_name
+                if _IsMapEntry(field):
+                    # Convert a map field.
+                    v_field = field.message_type.fields_by_name['value']
+                    js_map = {}
+                    for key in value:
+                        if isinstance(key, bool):
+                            if key:
+                                recorded_key = 'true'
+                            else:
+                                recorded_key = 'false'
+                        else:
+                            recorded_key = str(key)
+                        js_map[recorded_key] = self._FieldToJsonObject(
+                            v_field, value[key])
+                    js[name] = js_map
+                elif field.label == descriptor.FieldDescriptor.LABEL_REPEATED:
+                    # Convert a repeated field.
+                    js[name] = [self._FieldToJsonObject(field, k)
+                                for k in value]
+                elif field.is_extension:
+                    name = '[%s]' % field.full_name
+                    js[name] = self._FieldToJsonObject(field, value)
+                else:
+                    js[name] = self._FieldToJsonObject(field, value)
+
+            # Serialize default value if including_default_value_fields is True.
+            if self.including_default_value_fields:
+                message_descriptor = message.DESCRIPTOR
+                for field in message_descriptor.fields:
+                    # Singular message fields and oneof fields will not be affected.
+                    if ((field.label != descriptor.FieldDescriptor.LABEL_REPEATED and
+                         field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_MESSAGE) or
+                            field.containing_oneof):
+                        continue
+                    if self.preserving_proto_field_name:
+                        name = field.name
+                    else:
+                        name = field.json_name
+                    if name in js:
+                        # Skip the field which has been serialized already.
+                        continue
+                    if _IsMapEntry(field):
+                        js[name] = {}
+                    elif field.label == descriptor.FieldDescriptor.LABEL_REPEATED:
+                        js[name] = []
+                    else:
+                        js[name] = self._FieldToJsonObject(field, field.default_value)
+
+        except ValueError as e:
+            raise SerializeToJsonError(
+                'Failed to serialize {0} field: {1}.'.format(field.name, e))
+
+        return js
+
+    def _FieldToJsonObject(self, field, value):
+        """Converts field value according to Proto3 JSON Specification."""
+        if field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_MESSAGE:
+            return self._MessageToJsonObject(value)
+        elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_ENUM:
+            if self.use_integers_for_enums:
+                return value
+            if field.enum_type.full_name == 'google.protobuf.NullValue':
+                return None
+            enum_value = field.enum_type.values_by_number.get(value, None)
+            if enum_value is not None:
+                return enum_value.name
+            else:
+                if field.file.syntax == 'proto3':
+                    return value
+                raise SerializeToJsonError('Enum field contains an integer value '
+                                           'which can not mapped to an enum value.')
+        elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_STRING:
+            if field.type == descriptor.FieldDescriptor.TYPE_BYTES:
+                # Use base64 Data encoding for bytes
+                return base64.b64encode(value).decode('utf-8')
+            else:
+                return value
+        elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_BOOL:
+            return bool(value)
+        elif field.cpp_type in _INT64_TYPES:
+            return str(value)
+        elif field.cpp_type in _FLOAT_TYPES:
+            if math.isinf(value):
+                if value < 0.0:
+                    return _NEG_INFINITY
+                else:
+                    return _INFINITY
+            if math.isnan(value):
+                return _NAN
+            if field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_FLOAT:
+                if self.float_format:
+                    return float(format(value, self.float_format))
+                else:
+                    return type_checkers.ToShortestFloat(value)
+
+        return value
+
+    def _AnyMessageToJsonObject(self, message):
+        """Converts Any message according to Proto3 JSON Specification."""
+        if not message.ListFields():
+            return {}
+        # Must print @type first, use OrderedDict instead of {}
+        js = OrderedDict()
+        type_url = message.type_url
+        js['@type'] = type_url
+        sub_message = _CreateMessageFromTypeUrl(type_url, self.descriptor_pool)
+        sub_message.ParseFromString(message.value)
+        message_descriptor = sub_message.DESCRIPTOR
+        full_name = message_descriptor.full_name
+        if _IsWrapperMessage(message_descriptor):
+            js['value'] = self._WrapperMessageToJsonObject(sub_message)
+            return js
+        if full_name in _WKTJSONMETHODS:
+            js['value'] = methodcaller(_WKTJSONMETHODS[full_name][0],
+                                       sub_message)(self)
+            return js
+        return self._RegularMessageToJsonObject(sub_message, js)
+
+    def _GenericMessageToJsonObject(self, message):
+        """Converts message according to Proto3 JSON Specification."""
+        # Duration, Timestamp and FieldMask have ToJsonString method to do the
+        # convert. Users can also call the method directly.
+        return message.ToJsonString()
+
+    def _ValueMessageToJsonObject(self, message):
+        """Converts Value message according to Proto3 JSON Specification."""
+        which = message.WhichOneof('kind')
+        # If the Value message is not set treat as null_value when serialize
+        # to JSON. The parse back result will be different from original message.
+        if which is None or which == 'null_value':
+            return None
+        if which == 'list_value':
+            return self._ListValueMessageToJsonObject(message.list_value)
+        if which == 'struct_value':
+            value = message.struct_value
+        else:
+            value = getattr(message, which)
+        oneof_descriptor = message.DESCRIPTOR.fields_by_name[which]
+        return self._FieldToJsonObject(oneof_descriptor, value)
+
+    def _ListValueMessageToJsonObject(self, message):
+        """Converts ListValue message according to Proto3 JSON Specification."""
+        return [self._ValueMessageToJsonObject(value)
+                for value in message.values]
+
+    def _StructMessageToJsonObject(self, message):
+        """Converts Struct message according to Proto3 JSON Specification."""
+        fields = message.fields
+        ret = {}
+        for key in fields:
+            ret[key] = self._ValueMessageToJsonObject(fields[key])
+        return ret
+
+    def _WrapperMessageToJsonObject(self, message):
+        return self._FieldToJsonObject(
+            message.DESCRIPTOR.fields_by_name['value'], message.value)
+
+
+def _IsWrapperMessage(message_descriptor):
+    return message_descriptor.file.name == 'google/protobuf/wrappers.proto'
+
+
+def _DuplicateChecker(js):
+    result = {}
+    for name, value in js:
+        if name in result:
+            raise ParseError('Failed to load JSON: duplicate key {0}.'.format(name))
+        result[name] = value
+    return result
+
+
+def _CreateMessageFromTypeUrl(type_url, descriptor_pool):
+    """Creates a message from a type URL."""
+    db = symbol_database.Default()
+    pool = db.pool if descriptor_pool is None else descriptor_pool
+    type_name = type_url.split('/')[-1]
+    try:
+        message_descriptor = pool.FindMessageTypeByName(type_name)
+    except KeyError:
+        raise TypeError(
+            'Can not find message descriptor by type_url: {0}'.format(type_url))
+    message_class = db.GetPrototype(message_descriptor)
+    return message_class()
+
+
+def Parse(text,
+          message,
+          ignore_unknown_fields=False,
+          descriptor_pool=None,
+          max_recursion_depth=100):
+    """Parses a JSON representation of a protocol message into a message.
+
+    Args:
+      text: Message JSON representation.
+      message: A protocol buffer message to merge into.
+      ignore_unknown_fields: If True, do not raise errors for unknown fields.
+      descriptor_pool: A Descriptor Pool for resolving types. If None use the
+        default.
+      max_recursion_depth: max recursion depth of JSON message to be
+        deserialized. JSON messages over this depth will fail to be
+        deserialized. Default value is 100.
+
+    Returns:
+      The same message passed as argument.
+
+    Raises::
+      ParseError: On JSON parsing problems.
+    """
+    if not isinstance(text, str):
+        text = text.decode('utf-8')
+    try:
+        js = json.loads(text, object_pairs_hook=_DuplicateChecker)
+    except ValueError as e:
+        raise ParseError('Failed to load JSON: {0}.'.format(str(e)))
+    return ParseDict(js, message, ignore_unknown_fields, descriptor_pool,
+                     max_recursion_depth)
+
+
+def ParseDict(js_dict,
+              message,
+              ignore_unknown_fields=False,
+              descriptor_pool=None,
+              max_recursion_depth=100):
+    """Parses a JSON dictionary representation into a message.
+
+    Args:
+      js_dict: Dict representation of a JSON message.
+      message: A protocol buffer message to merge into.
+      ignore_unknown_fields: If True, do not raise errors for unknown fields.
+      descriptor_pool: A Descriptor Pool for resolving types. If None use the
+        default.
+      max_recursion_depth: max recursion depth of JSON message to be
+        deserialized. JSON messages over this depth will fail to be
+        deserialized. Default value is 100.
+
+    Returns:
+      The same message passed as argument.
+    """
+    parser = _Parser(ignore_unknown_fields, descriptor_pool, max_recursion_depth)
+    parser.ConvertMessage(js_dict, message, '')
+    return message
+
+
+_INT_OR_FLOAT = (int, float)
+
+
+class _Parser(object):
+    """JSON format parser for protocol message."""
+
+    def __init__(self, ignore_unknown_fields, descriptor_pool,
+                 max_recursion_depth):
+        self.ignore_unknown_fields = ignore_unknown_fields
+        self.descriptor_pool = descriptor_pool
+        self.max_recursion_depth = max_recursion_depth
+        self.recursion_depth = 0
+
+    def ConvertMessage(self, value, message, path):
+        """Convert a JSON object into a message.
+
+        Args:
+          value: A JSON object.
+          message: A WKT or regular protocol message to record the data.
+          path: parent path to log parse error info.
+
+        Raises:
+          ParseError: In case of convert problems.
+        """
+        self.recursion_depth += 1
+        if self.recursion_depth > self.max_recursion_depth:
+            raise ParseError('Message too deep. Max recursion depth is {0}'.format(
+                self.max_recursion_depth))
+        message_descriptor = message.DESCRIPTOR
+        full_name = message_descriptor.full_name
+        if not path:
+            path = message_descriptor.name
+        if _IsWrapperMessage(message_descriptor):
+            self._ConvertWrapperMessage(value, message, path)
+        elif full_name in _WKTJSONMETHODS:
+            methodcaller(_WKTJSONMETHODS[full_name][1], value, message, path)(self)
+        else:
+            self._ConvertFieldValuePair(value, message, path)
+        self.recursion_depth -= 1
+
+    def _ConvertFieldValuePair(self, js, message, path):
+        """Convert field value pairs into regular message.
+
+        Args:
+          js: A JSON object to convert the field value pairs.
+          message: A regular protocol message to record the data.
+          path: parent path to log parse error info.
+
+        Raises:
+          ParseError: In case of problems converting.
+        """
+        names = []
+        message_descriptor = message.DESCRIPTOR
+        fields_by_json_name = dict((f.json_name, f)
+                                   for f in message_descriptor.fields)
+        for name in js:
+            try:
+                field = fields_by_json_name.get(name, None)
+                if not field:
+                    field = message_descriptor.fields_by_name.get(name, None)
+                if not field and _VALID_EXTENSION_NAME.match(name):
+                    if not message_descriptor.is_extendable:
+                        raise ParseError(
+                            'Message type {0} does not have extensions at {1}'.format(
+                                message_descriptor.full_name, path))
+                    identifier = name[1:-1]  # strip [] brackets
+                    # pylint: disable=protected-access
+                    field = message.Extensions._FindExtensionByName(identifier)
+                    # pylint: enable=protected-access
+                    if not field:
+                        # Try looking for extension by the message type name, dropping the
+                        # field name following the final . separator in full_name.
+                        identifier = '.'.join(identifier.split('.')[:-1])
+                        # pylint: disable=protected-access
+                        field = message.Extensions._FindExtensionByName(identifier)
+                        # pylint: enable=protected-access
+                if not field:
+                    if self.ignore_unknown_fields:
+                        continue
+                    raise ParseError(
+                        ('Message type "{0}" has no field named "{1}" at "{2}".\n'
+                         ' Available Fields(except extensions): "{3}"').format(
+                            message_descriptor.full_name, name, path,
+                            [f.json_name for f in message_descriptor.fields]))
+                if name in names:
+                    raise ParseError('Message type "{0}" should not have multiple '
+                                     '"{1}" fields at "{2}".'.format(
+                        message.DESCRIPTOR.full_name, name, path))
+                names.append(name)
+                value = js[name]
+                # Check no other oneof field is parsed.
+                if field.containing_oneof is not None and value is not None:
+                    oneof_name = field.containing_oneof.name
+                    if oneof_name in names:
+                        raise ParseError('Message type "{0}" should not have multiple '
+                                         '"{1}" oneof fields at "{2}".'.format(
+                            message.DESCRIPTOR.full_name, oneof_name,
+                            path))
+                    names.append(oneof_name)
+
+                if value is None:
+                    if (field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_MESSAGE
+                            and field.message_type.full_name == 'google.protobuf.Value'):
+                        sub_message = getattr(message, field.name)
+                        sub_message.null_value = 0
+                    elif (field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_ENUM
+                          and field.enum_type.full_name == 'google.protobuf.NullValue'):
+                        setattr(message, field.name, 0)
+                    else:
+                        message.ClearField(field.name)
+                    continue
+
+                # Parse field value.
+                if _IsMapEntry(field):
+                    message.ClearField(field.name)
+                    self._ConvertMapFieldValue(value, message, field,
+                                               '{0}.{1}'.format(path, name))
+                elif field.label == descriptor.FieldDescriptor.LABEL_REPEATED:
+                    message.ClearField(field.name)
+                    if not isinstance(value, list):
+                        raise ParseError('repeated field {0} must be in [] which is '
+                                         '{1} at {2}'.format(name, value, path))
+                    if field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_MESSAGE:
+                        # Repeated message field.
+                        for index, item in enumerate(value):
+                            sub_message = getattr(message, field.name).add()
+                            # None is a null_value in Value.
+                            if (item is None and
+                                    sub_message.DESCRIPTOR.full_name != 'google.protobuf.Value'):
+                                raise ParseError('null is not allowed to be used as an element'
+                                                 ' in a repeated field at {0}.{1}[{2}]'.format(
+                                    path, name, index))
+                            self.ConvertMessage(item, sub_message,
+                                                '{0}.{1}[{2}]'.format(path, name, index))
+                    else:
+                        # Repeated scalar field.
+                        for index, item in enumerate(value):
+                            if item is None:
+                                raise ParseError('null is not allowed to be used as an element'
+                                                 ' in a repeated field at {0}.{1}[{2}]'.format(
+                                    path, name, index))
+                            getattr(message, field.name).append(
+                                _ConvertScalarFieldValue(
+                                    item, field, '{0}.{1}[{2}]'.format(path, name, index)))
+                elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_MESSAGE:
+                    if field.is_extension:
+                        sub_message = message.Extensions[field]
+                    else:
+                        sub_message = getattr(message, field.name)
+                    sub_message.SetInParent()
+                    self.ConvertMessage(value, sub_message, '{0}.{1}'.format(path, name))
+                else:
+                    if field.is_extension:
+                        message.Extensions[field] = _ConvertScalarFieldValue(
+                            value, field, '{0}.{1}'.format(path, name))
+                    else:
+                        setattr(
+                            message, field.name,
+                            _ConvertScalarFieldValue(value, field,
+                                                     '{0}.{1}'.format(path, name)))
+            except ParseError as e:
+                if field and field.containing_oneof is None:
+                    raise ParseError('Failed to parse {0} field: {1}.'.format(name, e))
+                else:
+                    raise ParseError(str(e))
+            except ValueError as e:
+                raise ParseError('Failed to parse {0} field: {1}.'.format(name, e))
+            except TypeError as e:
+                raise ParseError('Failed to parse {0} field: {1}.'.format(name, e))
+
+    def _ConvertAnyMessage(self, value, message, path):
+        """Convert a JSON representation into Any message."""
+        if isinstance(value, dict) and not value:
+            return
+        try:
+            type_url = value['@type']
+        except KeyError:
+            raise ParseError(
+                '@type is missing when parsing any message at {0}'.format(path))
+
+        try:
+            sub_message = _CreateMessageFromTypeUrl(type_url, self.descriptor_pool)
+        except TypeError as e:
+            raise ParseError('{0} at {1}'.format(e, path))
+        message_descriptor = sub_message.DESCRIPTOR
+        full_name = message_descriptor.full_name
+        if _IsWrapperMessage(message_descriptor):
+            self._ConvertWrapperMessage(value['value'], sub_message,
+                                        '{0}.value'.format(path))
+        elif full_name in _WKTJSONMETHODS:
+            methodcaller(_WKTJSONMETHODS[full_name][1], value['value'], sub_message,
+                         '{0}.value'.format(path))(
+                self)
+        else:
+            del value['@type']
+            self._ConvertFieldValuePair(value, sub_message, path)
+            value['@type'] = type_url
+        # Sets Any message
+        message.value = sub_message.SerializeToString()
+        message.type_url = type_url
+
+    def _ConvertGenericMessage(self, value, message, path):
+        """Convert a JSON representation into message with FromJsonString."""
+        # Duration, Timestamp, FieldMask have a FromJsonString method to do the
+        # conversion. Users can also call the method directly.
+        try:
+            message.FromJsonString(value)
+        except ValueError as e:
+            raise ParseError('{0} at {1}'.format(e, path))
+
+    def _ConvertValueMessage(self, value, message, path):
+        """Convert a JSON representation into Value message."""
+        if isinstance(value, dict):
+            self._ConvertStructMessage(value, message.struct_value, path)
+        elif isinstance(value, list):
+            self._ConvertListValueMessage(value, message.list_value, path)
+        elif value is None:
+            message.null_value = 0
+        elif isinstance(value, bool):
+            message.bool_value = value
+        elif isinstance(value, str):
+            message.string_value = value
+        elif isinstance(value, _INT_OR_FLOAT):
+            message.number_value = value
+        else:
+            raise ParseError('Value {0} has unexpected type {1} at {2}'.format(
+                value, type(value), path))
+
+    def _ConvertListValueMessage(self, value, message, path):
+        """Convert a JSON representation into ListValue message."""
+        if not isinstance(value, list):
+            raise ParseError('ListValue must be in [] which is {0} at {1}'.format(
+                value, path))
+        message.ClearField('values')
+        for index, item in enumerate(value):
+            self._ConvertValueMessage(item, message.values.add(),
+                                      '{0}[{1}]'.format(path, index))
+
+    def _ConvertStructMessage(self, value, message, path):
+        """Convert a JSON representation into Struct message."""
+        if not isinstance(value, dict):
+            raise ParseError('Struct must be in a dict which is {0} at {1}'.format(
+                value, path))
+        # Clear will mark the struct as modified so it will be created even if
+        # there are no values.
+        message.Clear()
+        for key in value:
+            self._ConvertValueMessage(value[key], message.fields[key],
+                                      '{0}.{1}'.format(path, key))
+        return
+
+    def _ConvertWrapperMessage(self, value, message, path):
+        """Convert a JSON representation into Wrapper message."""
+        field = message.DESCRIPTOR.fields_by_name['value']
+        setattr(
+            message, 'value',
+            _ConvertScalarFieldValue(value, field, path='{0}.value'.format(path)))
+
+    def _ConvertMapFieldValue(self, value, message, field, path):
+        """Convert map field value for a message map field.
+
+        Args:
+          value: A JSON object to convert the map field value.
+          message: A protocol message to record the converted data.
+          field: The descriptor of the map field to be converted.
+          path: parent path to log parse error info.
+
+        Raises:
+          ParseError: In case of convert problems.
+        """
+        if not isinstance(value, dict):
+            raise ParseError(
+                'Map field {0} must be in a dict which is {1} at {2}'.format(
+                    field.name, value, path))
+        key_field = field.message_type.fields_by_name['key']
+        value_field = field.message_type.fields_by_name['value']
+        for key in value:
+            key_value = _ConvertScalarFieldValue(key, key_field,
+                                                 '{0}.key'.format(path), True)
+            if value_field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_MESSAGE:
+                self.ConvertMessage(value[key],
+                                    getattr(message, field.name)[key_value],
+                                    '{0}[{1}]'.format(path, key_value))
+            else:
+                getattr(message, field.name)[key_value] = _ConvertScalarFieldValue(
+                    value[key], value_field, path='{0}[{1}]'.format(path, key_value))
+
+
+def _ConvertScalarFieldValue(value, field, path, require_str=False):
+    """Convert a single scalar field value.
+
+    Args:
+      value: A scalar value to convert the scalar field value.
+      field: The descriptor of the field to convert.
+      path: parent path to log parse error info.
+      require_str: If True, the field value must be a str.
+
+    Returns:
+      The converted scalar field value
+
+    Raises:
+      ParseError: In case of convert problems.
+    """
+    try:
+        if field.cpp_type in _INT_TYPES:
+            return _ConvertInteger(value)
+        elif field.cpp_type in _FLOAT_TYPES:
+            return _ConvertFloat(value, field)
+        elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_BOOL:
+            return _ConvertBool(value, require_str)
+        elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_STRING:
+            if field.type == descriptor.FieldDescriptor.TYPE_BYTES:
+                if isinstance(value, str):
+                    encoded = value.encode('utf-8')
+                else:
+                    encoded = value
+                # Add extra padding '='
+                padded_value = encoded + b'=' * (4 - len(encoded) % 4)
+                return base64.urlsafe_b64decode(padded_value)
+            else:
+                # Checking for unpaired surrogates appears to be unreliable,
+                # depending on the specific Python version, so we check manually.
+                if _UNPAIRED_SURROGATE_PATTERN.search(value):
+                    raise ParseError('Unpaired surrogate')
+                return value
+        elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_ENUM:
+            # Convert an enum value.
+            enum_value = field.enum_type.values_by_name.get(value, None)
+            if enum_value is None:
+                try:
+                    number = int(value)
+                    enum_value = field.enum_type.values_by_number.get(number, None)
+                except ValueError:
+                    raise ParseError('Invalid enum value {0} for enum type {1}'.format(
+                        value, field.enum_type.full_name))
+                if enum_value is None:
+                    if field.file.syntax == 'proto3':
+                        # Proto3 accepts unknown enums.
+                        return number
+                    raise ParseError('Invalid enum value {0} for enum type {1}'.format(
+                        value, field.enum_type.full_name))
+            return enum_value.number
+    except ParseError as e:
+        raise ParseError('{0} at {1}'.format(e, path))
+
+
+def _ConvertInteger(value):
+    """Convert an integer.
+
+    Args:
+      value: A scalar value to convert.
+
+    Returns:
+      The integer value.
+
+    Raises:
+      ParseError: If an integer couldn't be consumed.
+    """
+    if isinstance(value, float) and not value.is_integer():
+        raise ParseError('Couldn\'t parse integer: {0}'.format(value))
+
+    if isinstance(value, str) and value.find(' ') != -1:
+        raise ParseError('Couldn\'t parse integer: "{0}"'.format(value))
+
+    if isinstance(value, bool):
+        raise ParseError('Bool value {0} is not acceptable for '
+                         'integer field'.format(value))
+
+    return int(value)
+
+
+def _ConvertFloat(value, field):
+    """Convert an floating point number."""
+    if isinstance(value, float):
+        if math.isnan(value):
+            raise ParseError('Couldn\'t parse NaN, use quoted "NaN" instead')
+        if math.isinf(value):
+            if value > 0:
+                raise ParseError('Couldn\'t parse Infinity or value too large, '
+                                 'use quoted "Infinity" instead')
+            else:
+                raise ParseError('Couldn\'t parse -Infinity or value too small, '
+                                 'use quoted "-Infinity" instead')
+        if field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_FLOAT:
+            # pylint: disable=protected-access
+            if value > type_checkers._FLOAT_MAX:
+                raise ParseError('Float value too large')
+            # pylint: disable=protected-access
+            if value < type_checkers._FLOAT_MIN:
+                raise ParseError('Float value too small')
+    if value == 'nan':
+        raise ParseError('Couldn\'t parse float "nan", use "NaN" instead')
+    try:
+        # Assume Python compatible syntax.
+        return float(value)
+    except ValueError:
+        # Check alternative spellings.
+        if value == _NEG_INFINITY:
+            return float('-inf')
+        elif value == _INFINITY:
+            return float('inf')
+        elif value == _NAN:
+            return float('nan')
+        else:
+            raise ParseError('Couldn\'t parse float: {0}'.format(value))
+
+
+def _ConvertBool(value, require_str):
+    """Convert a boolean value.
+
+    Args:
+      value: A scalar value to convert.
+      require_str: If True, value must be a str.
+
+    Returns:
+      The bool parsed.
+
+    Raises:
+      ParseError: If a boolean value couldn't be consumed.
+    """
+    if require_str:
+        if value == 'true':
+            return True
+        elif value == 'false':
+            return False
+        else:
+            raise ParseError('Expected "true" or "false", not {0}'.format(value))
+
+    if not isinstance(value, bool):
+        raise ParseError('Expected true or false without quotes')
+    return value
+
+
+_WKTJSONMETHODS = {
+    'google.protobuf.Any': ['_AnyMessageToJsonObject',
+                            '_ConvertAnyMessage'],
+    'google.protobuf.Duration': ['_GenericMessageToJsonObject',
+                                 '_ConvertGenericMessage'],
+    'google.protobuf.FieldMask': ['_GenericMessageToJsonObject',
+                                  '_ConvertGenericMessage'],
+    'google.protobuf.ListValue': ['_ListValueMessageToJsonObject',
+                                  '_ConvertListValueMessage'],
+    'google.protobuf.Struct': ['_StructMessageToJsonObject',
+                               '_ConvertStructMessage'],
+    'google.protobuf.Timestamp': ['_GenericMessageToJsonObject',
+                                  '_ConvertGenericMessage'],
+    'google.protobuf.Value': ['_ValueMessageToJsonObject',
+                              '_ConvertValueMessage']
+}
diff --git a/lark_channel/ws/pb/google/protobuf/message.py b/lark_channel/ws/pb/google/protobuf/message.py
new file mode 100644
index 0000000..cd01ad3
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/message.py
@@ -0,0 +1,424 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+# https://developers.google.com/protocol-buffers/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# TODO(robinson): We should just make these methods all "pure-virtual" and move
+# all implementation out, into reflection.py for now.
+
+
+"""Contains an abstract base class for protocol messages."""
+
+__author__ = 'robinson@google.com (Will Robinson)'
+
+
+class Error(Exception):
+    """Base error type for this module."""
+    pass
+
+
+class DecodeError(Error):
+    """Exception raised when deserializing messages."""
+    pass
+
+
+class EncodeError(Error):
+    """Exception raised when serializing messages."""
+    pass
+
+
+class Message(object):
+    """Abstract base class for protocol messages.
+
+    Protocol message classes are almost always generated by the protocol
+    compiler.  These generated types subclass Message and implement the methods
+    shown below.
+    """
+
+    # TODO(robinson): Link to an HTML document here.
+
+    # TODO(robinson): Document that instances of this class will also
+    # have an Extensions attribute with __getitem__ and __setitem__.
+    # Again, not sure how to best convey this.
+
+    # TODO(robinson): Document that the class must also have a static
+    #   RegisterExtension(extension_field) method.
+    #   Not sure how to best express at this point.
+
+    # TODO(robinson): Document these fields and methods.
+
+    __slots__ = []
+
+    #: The :class:`google.protobuf.descriptor.Descriptor` for this message type.
+    DESCRIPTOR = None
+
+    def __deepcopy__(self, memo=None):
+        clone = type(self)()
+        clone.MergeFrom(self)
+        return clone
+
+    def __eq__(self, other_msg):
+        """Recursively compares two messages by value and structure."""
+        raise NotImplementedError
+
+    def __ne__(self, other_msg):
+        # Can't just say self != other_msg, since that would infinitely recurse. :)
+        return not self == other_msg
+
+    def __hash__(self):
+        raise TypeError('unhashable object')
+
+    def __str__(self):
+        """Outputs a human-readable representation of the message."""
+        raise NotImplementedError
+
+    def __unicode__(self):
+        """Outputs a human-readable representation of the message."""
+        raise NotImplementedError
+
+    def MergeFrom(self, other_msg):
+        """Merges the contents of the specified message into current message.
+
+        This method merges the contents of the specified message into the current
+        message. Singular fields that are set in the specified message overwrite
+        the corresponding fields in the current message. Repeated fields are
+        appended. Singular sub-messages and groups are recursively merged.
+
+        Args:
+          other_msg (Message): A message to merge into the current message.
+        """
+        raise NotImplementedError
+
+    def CopyFrom(self, other_msg):
+        """Copies the content of the specified message into the current message.
+
+        The method clears the current message and then merges the specified
+        message using MergeFrom.
+
+        Args:
+          other_msg (Message): A message to copy into the current one.
+        """
+        if self is other_msg:
+            return
+        self.Clear()
+        self.MergeFrom(other_msg)
+
+    def Clear(self):
+        """Clears all data that was set in the message."""
+        raise NotImplementedError
+
+    def SetInParent(self):
+        """Mark this as present in the parent.
+
+        This normally happens automatically when you assign a field of a
+        sub-message, but sometimes you want to make the sub-message
+        present while keeping it empty.  If you find yourself using this,
+        you may want to reconsider your design.
+        """
+        raise NotImplementedError
+
+    def IsInitialized(self):
+        """Checks if the message is initialized.
+
+        Returns:
+          bool: The method returns True if the message is initialized (i.e. all of
+          its required fields are set).
+        """
+        raise NotImplementedError
+
+    # TODO(robinson): MergeFromString() should probably return None and be
+    # implemented in terms of a helper that returns the # of bytes read.  Our
+    # deserialization routines would use the helper when recursively
+    # deserializing, but the end user would almost always just want the no-return
+    # MergeFromString().
+
+    def MergeFromString(self, serialized):
+        """Merges serialized protocol buffer data into this message.
+
+        When we find a field in `serialized` that is already present
+        in this message:
+
+        -   If it's a "repeated" field, we append to the end of our list.
+        -   Else, if it's a scalar, we overwrite our field.
+        -   Else, (it's a nonrepeated composite), we recursively merge
+            into the existing composite.
+
+        Args:
+          serialized (bytes): Any object that allows us to call
+            ``memoryview(serialized)`` to access a string of bytes using the
+            buffer interface.
+
+        Returns:
+          int: The number of bytes read from `serialized`.
+          For non-group messages, this will always be `len(serialized)`,
+          but for messages which are actually groups, this will
+          generally be less than `len(serialized)`, since we must
+          stop when we reach an ``END_GROUP`` tag.  Note that if
+          we *do* stop because of an ``END_GROUP`` tag, the number
+          of bytes returned does not include the bytes
+          for the ``END_GROUP`` tag information.
+
+        Raises:
+          DecodeError: if the input cannot be parsed.
+        """
+        # TODO(robinson): Document handling of unknown fields.
+        # TODO(robinson): When we switch to a helper, this will return None.
+        raise NotImplementedError
+
+    def ParseFromString(self, serialized):
+        """Parse serialized protocol buffer data into this message.
+
+        Like :func:`MergeFromString()`, except we clear the object first.
+
+        Raises:
+          message.DecodeError if the input cannot be parsed.
+        """
+        self.Clear()
+        return self.MergeFromString(serialized)
+
+    def SerializeToString(self, **kwargs):
+        """Serializes the protocol message to a binary string.
+
+        Keyword Args:
+          deterministic (bool): If true, requests deterministic serialization
+            of the protobuf, with predictable ordering of map keys.
+
+        Returns:
+          A binary string representation of the message if all of the required
+          fields in the message are set (i.e. the message is initialized).
+
+        Raises:
+          EncodeError: if the message isn't initialized (see :func:`IsInitialized`).
+        """
+        raise NotImplementedError
+
+    def SerializePartialToString(self, **kwargs):
+        """Serializes the protocol message to a binary string.
+
+        This method is similar to SerializeToString but doesn't check if the
+        message is initialized.
+
+        Keyword Args:
+          deterministic (bool): If true, requests deterministic serialization
+            of the protobuf, with predictable ordering of map keys.
+
+        Returns:
+          bytes: A serialized representation of the partial message.
+        """
+        raise NotImplementedError
+
+    # TODO(robinson): Decide whether we like these better
+    # than auto-generated has_foo() and clear_foo() methods
+    # on the instances themselves.  This way is less consistent
+    # with C++, but it makes reflection-type access easier and
+    # reduces the number of magically autogenerated things.
+    #
+    # TODO(robinson): Be sure to document (and test) exactly
+    # which field names are accepted here.  Are we case-sensitive?
+    # What do we do with fields that share names with Python keywords
+    # like 'lambda' and 'yield'?
+    #
+    # nnorwitz says:
+    # """
+    # Typically (in python), an underscore is appended to names that are
+    # keywords. So they would become lambda_ or yield_.
+    # """
+    def ListFields(self):
+        """Returns a list of (FieldDescriptor, value) tuples for present fields.
+
+        A message field is non-empty if HasField() would return true. A singular
+        primitive field is non-empty if HasField() would return true in proto2 or it
+        is non zero in proto3. A repeated field is non-empty if it contains at least
+        one element. The fields are ordered by field number.
+
+        Returns:
+          list[tuple(FieldDescriptor, value)]: field descriptors and values
+          for all fields in the message which are not empty. The values vary by
+          field type.
+        """
+        raise NotImplementedError
+
+    def HasField(self, field_name):
+        """Checks if a certain field is set for the message.
+
+        For a oneof group, checks if any field inside is set. Note that if the
+        field_name is not defined in the message descriptor, :exc:`ValueError` will
+        be raised.
+
+        Args:
+          field_name (str): The name of the field to check for presence.
+
+        Returns:
+          bool: Whether a value has been set for the named field.
+
+        Raises:
+          ValueError: if the `field_name` is not a member of this message.
+        """
+        raise NotImplementedError
+
+    def ClearField(self, field_name):
+        """Clears the contents of a given field.
+
+        Inside a oneof group, clears the field set. If the name neither refers to a
+        defined field or oneof group, :exc:`ValueError` is raised.
+
+        Args:
+          field_name (str): The name of the field to check for presence.
+
+        Raises:
+          ValueError: if the `field_name` is not a member of this message.
+        """
+        raise NotImplementedError
+
+    def WhichOneof(self, oneof_group):
+        """Returns the name of the field that is set inside a oneof group.
+
+        If no field is set, returns None.
+
+        Args:
+          oneof_group (str): the name of the oneof group to check.
+
+        Returns:
+          str or None: The name of the group that is set, or None.
+
+        Raises:
+          ValueError: no group with the given name exists
+        """
+        raise NotImplementedError
+
+    def HasExtension(self, extension_handle):
+        """Checks if a certain extension is present for this message.
+
+        Extensions are retrieved using the :attr:`Extensions` mapping (if present).
+
+        Args:
+          extension_handle: The handle for the extension to check.
+
+        Returns:
+          bool: Whether the extension is present for this message.
+
+        Raises:
+          KeyError: if the extension is repeated. Similar to repeated fields,
+            there is no separate notion of presence: a "not present" repeated
+            extension is an empty list.
+        """
+        raise NotImplementedError
+
+    def ClearExtension(self, extension_handle):
+        """Clears the contents of a given extension.
+
+        Args:
+          extension_handle: The handle for the extension to clear.
+        """
+        raise NotImplementedError
+
+    def UnknownFields(self):
+        """Returns the UnknownFieldSet.
+
+        Returns:
+          UnknownFieldSet: The unknown fields stored in this message.
+        """
+        raise NotImplementedError
+
+    def DiscardUnknownFields(self):
+        """Clears all fields in the :class:`UnknownFieldSet`.
+
+        This operation is recursive for nested message.
+        """
+        raise NotImplementedError
+
+    def ByteSize(self):
+        """Returns the serialized size of this message.
+
+        Recursively calls ByteSize() on all contained messages.
+
+        Returns:
+          int: The number of bytes required to serialize this message.
+        """
+        raise NotImplementedError
+
+    @classmethod
+    def FromString(cls, s):
+        raise NotImplementedError
+
+    @staticmethod
+    def RegisterExtension(extension_handle):
+        raise NotImplementedError
+
+    def _SetListener(self, message_listener):
+        """Internal method used by the protocol message implementation.
+        Clients should not call this directly.
+
+        Sets a listener that this message will call on certain state transitions.
+
+        The purpose of this method is to register back-edges from children to
+        parents at runtime, for the purpose of setting "has" bits and
+        byte-size-dirty bits in the parent and ancestor objects whenever a child or
+        descendant object is modified.
+
+        If the client wants to disconnect this Message from the object tree, she
+        explicitly sets callback to None.
+
+        If message_listener is None, unregisters any existing listener.  Otherwise,
+        message_listener must implement the MessageListener interface in
+        internal/message_listener.py, and we discard any listener registered
+        via a previous _SetListener() call.
+        """
+        raise NotImplementedError
+
+    def __getstate__(self):
+        """Support the pickle protocol."""
+        return dict(serialized=self.SerializePartialToString())
+
+    def __setstate__(self, state):
+        """Support the pickle protocol."""
+        self.__init__()
+        serialized = state['serialized']
+        # On Python 3, using encoding='latin1' is required for unpickling
+        # protos pickled by Python 2.
+        if not isinstance(serialized, bytes):
+            serialized = serialized.encode('latin1')
+        self.ParseFromString(serialized)
+
+    def __reduce__(self):
+        message_descriptor = self.DESCRIPTOR
+        if message_descriptor.containing_type is None:
+            return type(self), (), self.__getstate__()
+        # the message type must be nested.
+        # Python does not pickle nested classes; use the symbol_database on the
+        # receiving end.
+        container = message_descriptor
+        return (_InternalConstructMessage, (container.full_name,),
+                self.__getstate__())
+
+
+def _InternalConstructMessage(full_name):
+    """Constructs a nested message."""
+    from lark_channel.ws.pb.google.protobuf import symbol_database  # pylint:disable=g-import-not-at-top
+
+    return symbol_database.Default().GetSymbol(full_name)()
diff --git a/lark_channel/ws/pb/google/protobuf/message_factory.py b/lark_channel/ws/pb/google/protobuf/message_factory.py
new file mode 100644
index 0000000..f4d14c4
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/message_factory.py
@@ -0,0 +1,186 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+# https://developers.google.com/protocol-buffers/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""Provides a factory class for generating dynamic messages.
+
+The easiest way to use this class is if you have access to the FileDescriptor
+protos containing the messages you want to create you can just do the following:
+
+message_classes = message_factory.GetMessages(iterable_of_file_descriptors)
+my_proto_instance = message_classes['some.proto.package.MessageName']()
+"""
+
+__author__ = 'matthewtoia@google.com (Matt Toia)'
+
+from lark_channel.ws.pb.google.protobuf.internal import api_implementation
+from lark_channel.ws.pb.google.protobuf import descriptor_pool
+from lark_channel.ws.pb.google.protobuf import message
+
+if api_implementation.Type() == 'cpp':
+    from lark_channel.ws.pb.google.protobuf.pyext import cpp_message as message_impl
+else:
+    from lark_channel.ws.pb.google.protobuf.internal import python_message as message_impl
+
+# The type of all Message classes.
+_GENERATED_PROTOCOL_MESSAGE_TYPE = message_impl.GeneratedProtocolMessageType
+
+
+class MessageFactory(object):
+    """Factory for creating Proto2 messages from descriptors in a pool."""
+
+    def __init__(self, pool=None):
+        """Initializes a new factory."""
+        self.pool = pool or descriptor_pool.DescriptorPool()
+
+        # local cache of all classes built from protobuf descriptors
+        self._classes = {}
+
+    def GetPrototype(self, descriptor):
+        """Obtains a proto2 message class based on the passed in descriptor.
+
+        Passing a descriptor with a fully qualified name matching a previous
+        invocation will cause the same class to be returned.
+
+        Args:
+          descriptor: The descriptor to build from.
+
+        Returns:
+          A class describing the passed in descriptor.
+        """
+        if descriptor not in self._classes:
+            result_class = self.CreatePrototype(descriptor)
+            # The assignment to _classes is redundant for the base implementation, but
+            # might avoid confusion in cases where CreatePrototype gets overridden and
+            # does not call the base implementation.
+            self._classes[descriptor] = result_class
+            return result_class
+        return self._classes[descriptor]
+
+    def CreatePrototype(self, descriptor):
+        """Builds a proto2 message class based on the passed in descriptor.
+
+        Don't call this function directly, it always creates a new class. Call
+        GetPrototype() instead. This method is meant to be overridden in subblasses
+        to perform additional operations on the newly constructed class.
+
+        Args:
+          descriptor: The descriptor to build from.
+
+        Returns:
+          A class describing the passed in descriptor.
+        """
+        descriptor_name = descriptor.name
+        result_class = _GENERATED_PROTOCOL_MESSAGE_TYPE(
+            descriptor_name,
+            (message.Message,),
+            {
+                'DESCRIPTOR': descriptor,
+                # If module not set, it wrongly points to message_factory module.
+                '__module__': None,
+            })
+        result_class._FACTORY = self  # pylint: disable=protected-access
+        # Assign in _classes before doing recursive calls to avoid infinite
+        # recursion.
+        self._classes[descriptor] = result_class
+        for field in descriptor.fields:
+            if field.message_type:
+                self.GetPrototype(field.message_type)
+        for extension in result_class.DESCRIPTOR.extensions:
+            if extension.containing_type not in self._classes:
+                self.GetPrototype(extension.containing_type)
+            extended_class = self._classes[extension.containing_type]
+            extended_class.RegisterExtension(extension)
+        return result_class
+
+    def GetMessages(self, files):
+        """Gets all the messages from a specified file.
+
+        This will find and resolve dependencies, failing if the descriptor
+        pool cannot satisfy them.
+
+        Args:
+          files: The file names to extract messages from.
+
+        Returns:
+          A dictionary mapping proto names to the message classes. This will include
+          any dependent messages as well as any messages defined in the same file as
+          a specified message.
+        """
+        result = {}
+        for file_name in files:
+            file_desc = self.pool.FindFileByName(file_name)
+            for desc in file_desc.message_types_by_name.values():
+                result[desc.full_name] = self.GetPrototype(desc)
+
+            # While the extension FieldDescriptors are created by the descriptor pool,
+            # the python classes created in the factory need them to be registered
+            # explicitly, which is done below.
+            #
+            # The call to RegisterExtension will specifically check if the
+            # extension was already registered on the object and either
+            # ignore the registration if the original was the same, or raise
+            # an error if they were different.
+
+            for extension in file_desc.extensions_by_name.values():
+                if extension.containing_type not in self._classes:
+                    self.GetPrototype(extension.containing_type)
+                extended_class = self._classes[extension.containing_type]
+                extended_class.RegisterExtension(extension)
+        return result
+
+
+_FACTORY = MessageFactory()
+
+
+def GetMessages(file_protos):
+    """Builds a dictionary of all the messages available in a set of files.
+
+    Args:
+      file_protos: Iterable of FileDescriptorProto to build messages out of.
+
+    Returns:
+      A dictionary mapping proto names to the message classes. This will include
+      any dependent messages as well as any messages defined in the same file as
+      a specified message.
+    """
+    # The cpp implementation of the protocol buffer library requires to add the
+    # message in topological order of the dependency graph.
+    file_by_name = {file_proto.name: file_proto for file_proto in file_protos}
+
+    def _AddFile(file_proto):
+        for dependency in file_proto.dependency:
+            if dependency in file_by_name:
+                # Remove from elements to be visited, in order to cut cycles.
+                _AddFile(file_by_name.pop(dependency))
+        _FACTORY.pool.Add(file_proto)
+
+    while file_by_name:
+        _AddFile(file_by_name.popitem()[1])
+    return _FACTORY.GetMessages([file_proto.name for file_proto in file_protos])
diff --git a/lark_channel/ws/pb/google/protobuf/proto_api.h b/lark_channel/ws/pb/google/protobuf/proto_api.h
new file mode 100644
index 0000000..9969a91
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/proto_api.h
@@ -0,0 +1,145 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This file can be included by other C++ libraries, typically extension modules
+// which want to interact with the Python Messages coming from the "cpp"
+// implementation of protocol buffers.
+//
+// Usage:
+// Declare a (probably static) variable to hold the API:
+//    const PyProto_API* py_proto_api;
+// In some initialization function, write:
+//    py_proto_api = static_cast<const PyProto_API*>(PyCapsule_Import(
+//        PyProtoAPICapsuleName(), 0));
+//    if (!py_proto_api) { ...handle ImportError... }
+// Then use the methods of the returned class:
+//    py_proto_api->GetMessagePointer(...);
+
+#ifndef GOOGLE_PROTOBUF_PYTHON_PROTO_API_H__
+#define GOOGLE_PROTOBUF_PYTHON_PROTO_API_H__
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+#include <google/protobuf/descriptor_database.h>
+#include <google/protobuf/message.h>
+
+namespace google {
+namespace protobuf {
+namespace python {
+
+// Note on the implementation:
+// This API is designed after
+// https://docs.python.org/3/extending/extending.html#providing-a-c-api-for-an-extension-module
+// The class below contains no mutable state, and all methods are "const";
+// we use a C++ class instead of a C struct with functions pointers just because
+// the code looks more readable.
+struct PyProto_API {
+  // The API object is created at initialization time and never freed.
+  // This destructor is never called.
+  virtual ~PyProto_API() {}
+
+  // Operations on Messages.
+
+  // If the passed object is a Python Message, returns its internal pointer.
+  // Otherwise, returns NULL with an exception set.
+  virtual const Message* GetMessagePointer(PyObject* msg) const = 0;
+
+  // If the passed object is a Python Message, returns a mutable pointer.
+  // Otherwise, returns NULL with an exception set.
+  // This function will succeed only if there are no other Python objects
+  // pointing to the message, like submessages or repeated containers.
+  // With the current implementation, only empty messages are in this case.
+  virtual Message* GetMutableMessagePointer(PyObject* msg) const = 0;
+
+  // If the passed object is a Python Message Descriptor, returns its internal
+  // pointer.
+  // Otherwise, returns NULL with an exception set.
+  virtual const Descriptor* MessageDescriptor_AsDescriptor(
+      PyObject* desc) const = 0;
+
+  // If the passed object is a Python Enum Descriptor, returns its internal
+  // pointer.
+  // Otherwise, returns NULL with an exception set.
+  virtual const EnumDescriptor* EnumDescriptor_AsDescriptor(
+      PyObject* enum_desc) const = 0;
+
+  // Expose the underlying DescriptorPool and MessageFactory to enable C++ code
+  // to create Python-compatible message.
+  virtual const DescriptorPool* GetDefaultDescriptorPool() const = 0;
+  virtual MessageFactory* GetDefaultMessageFactory() const = 0;
+
+  // Allocate a new protocol buffer as a python object for the provided
+  // descriptor. This function works even if no Python module has been imported
+  // for the corresponding protocol buffer class.
+  // The factory is usually null; when provided, it is the MessageFactory which
+  // owns the Python class, and will be used to find and create Extensions for
+  // this message.
+  // When null is returned, a python error has already been set.
+  virtual PyObject* NewMessage(const Descriptor* descriptor,
+                               PyObject* py_message_factory) const = 0;
+
+  // Allocate a new protocol buffer where the underlying object is owned by C++.
+  // The factory must currently be null.  This function works even if no Python
+  // module has been imported for the corresponding protocol buffer class.
+  // When null is returned, a python error has already been set.
+  //
+  // Since this call returns a python object owned by C++, some operations
+  // are risky, and it must be used carefully. In particular:
+  // * Avoid modifying the returned object from the C++ side while there are
+  // existing python references to it or it's subobjects.
+  // * Avoid using python references to this object or any subobjects after the
+  // C++ object has been freed.
+  // * Calling this with the same C++ pointer will result in multiple distinct
+  // python objects referencing the same C++ object.
+  virtual PyObject* NewMessageOwnedExternally(
+      Message* msg, PyObject* py_message_factory) const = 0;
+
+  // Returns a new reference for the given DescriptorPool.
+  // The returned object does not manage the C++ DescriptorPool: it is the
+  // responsibility of the caller to keep it alive.
+  // As long as the returned Python DescriptorPool object is kept alive,
+  // functions that process C++ descriptors or messages created from this pool
+  // can work and return their Python counterparts.
+  virtual PyObject* DescriptorPool_FromPool(
+      const google::protobuf::DescriptorPool* pool) const = 0;
+};
+
+inline const char* PyProtoAPICapsuleName() {
+  static const char kCapsuleName[] =
+      "google.protobuf.pyext._message.proto_API";
+  return kCapsuleName;
+}
+
+}  // namespace python
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_PYTHON_PROTO_API_H__
diff --git a/lark_channel/ws/pb/google/protobuf/proto_builder.py b/lark_channel/ws/pb/google/protobuf/proto_builder.py
new file mode 100644
index 0000000..b9cacce
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/proto_builder.py
@@ -0,0 +1,134 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+# https://developers.google.com/protocol-buffers/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""Dynamic Protobuf class creator."""
+
+from collections import OrderedDict
+import hashlib
+import os
+
+from lark_channel.ws.pb.google.protobuf import descriptor_pb2
+from lark_channel.ws.pb.google.protobuf import descriptor
+from lark_channel.ws.pb.google.protobuf import message_factory
+
+
+def _GetMessageFromFactory(factory, full_name):
+    """Get a proto class from the MessageFactory by name.
+
+    Args:
+      factory: a MessageFactory instance.
+      full_name: str, the fully qualified name of the proto type.
+    Returns:
+      A class, for the type identified by full_name.
+    Raises:
+      KeyError, if the proto is not found in the factory's descriptor pool.
+    """
+    proto_descriptor = factory.pool.FindMessageTypeByName(full_name)
+    proto_cls = factory.GetPrototype(proto_descriptor)
+    return proto_cls
+
+
+def MakeSimpleProtoClass(fields, full_name=None, pool=None):
+    """Create a Protobuf class whose fields are basic types.
+
+    Note: this doesn't validate field names!
+
+    Args:
+      fields: dict of {name: field_type} mappings for each field in the proto. If
+          this is an OrderedDict the order will be maintained, otherwise the
+          fields will be sorted by name.
+      full_name: optional str, the fully-qualified name of the proto type.
+      pool: optional DescriptorPool instance.
+    Returns:
+      a class, the new protobuf class with a FileDescriptor.
+    """
+    factory = message_factory.MessageFactory(pool=pool)
+
+    if full_name is not None:
+        try:
+            proto_cls = _GetMessageFromFactory(factory, full_name)
+            return proto_cls
+        except KeyError:
+            # The factory's DescriptorPool doesn't know about this class yet.
+            pass
+
+    # Get a list of (name, field_type) tuples from the fields dict. If fields was
+    # an OrderedDict we keep the order, but otherwise we sort the field to ensure
+    # consistent ordering.
+    field_items = fields.items()
+    if not isinstance(fields, OrderedDict):
+        field_items = sorted(field_items)
+
+    # Use a consistent file name that is unlikely to conflict with any imported
+    # proto files.
+    fields_hash = hashlib.sha1()
+    for f_name, f_type in field_items:
+        fields_hash.update(f_name.encode('utf-8'))
+        fields_hash.update(str(f_type).encode('utf-8'))
+    proto_file_name = fields_hash.hexdigest() + '.proto'
+
+    # If the proto is anonymous, use the same hash to name it.
+    if full_name is None:
+        full_name = ('net.proto2.python.public.proto_builder.AnonymousProto_' +
+                     fields_hash.hexdigest())
+        try:
+            proto_cls = _GetMessageFromFactory(factory, full_name)
+            return proto_cls
+        except KeyError:
+            # The factory's DescriptorPool doesn't know about this class yet.
+            pass
+
+    # This is the first time we see this proto: add a new descriptor to the pool.
+    factory.pool.Add(
+        _MakeFileDescriptorProto(proto_file_name, full_name, field_items))
+    return _GetMessageFromFactory(factory, full_name)
+
+
+def _MakeFileDescriptorProto(proto_file_name, full_name, field_items):
+    """Populate FileDescriptorProto for MessageFactory's DescriptorPool."""
+    package, name = full_name.rsplit('.', 1)
+    file_proto = descriptor_pb2.FileDescriptorProto()
+    file_proto.name = os.path.join(package.replace('.', '/'), proto_file_name)
+    file_proto.package = package
+    desc_proto = file_proto.message_type.add()
+    desc_proto.name = name
+    for f_number, (f_name, f_type) in enumerate(field_items, 1):
+        field_proto = desc_proto.field.add()
+        field_proto.name = f_name
+        # # If the number falls in the reserved range, reassign it to the correct
+        # # number after the range.
+        if f_number >= descriptor.FieldDescriptor.FIRST_RESERVED_FIELD_NUMBER:
+            f_number += (
+                    descriptor.FieldDescriptor.LAST_RESERVED_FIELD_NUMBER -
+                    descriptor.FieldDescriptor.FIRST_RESERVED_FIELD_NUMBER + 1)
+        field_proto.number = f_number
+        field_proto.label = descriptor_pb2.FieldDescriptorProto.LABEL_OPTIONAL
+        field_proto.type = f_type
+    return file_proto
diff --git a/lark_channel/ws/pb/google/protobuf/pyext/__init__.py b/lark_channel/ws/pb/google/protobuf/pyext/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/lark_channel/ws/pb/google/protobuf/pyext/cpp_message.py b/lark_channel/ws/pb/google/protobuf/pyext/cpp_message.py
new file mode 100644
index 0000000..8426439
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/pyext/cpp_message.py
@@ -0,0 +1,64 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+# https://developers.google.com/protocol-buffers/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""Protocol message implementation hooks for C++ implementation.
+
+Contains helper functions used to create protocol message classes from
+Descriptor objects at runtime backed by the protocol buffer C++ API.
+"""
+
+__author__ = 'tibell@google.com (Johan Tibell)'
+
+from lark_channel.ws.pb.google.protobuf.pyext import _message
+
+
+class GeneratedProtocolMessageType(_message.MessageMeta):
+    """Metaclass for protocol message classes created at runtime from Descriptors.
+
+    The protocol compiler currently uses this metaclass to create protocol
+    message classes at runtime.  Clients can also manually create their own
+    classes at runtime, as in this example:
+
+    mydescriptor = Descriptor(.....)
+    factory = symbol_database.Default()
+    factory.pool.AddDescriptor(mydescriptor)
+    MyProtoClass = factory.GetPrototype(mydescriptor)
+    myproto_instance = MyProtoClass()
+    myproto.foo_field = 23
+    ...
+
+    The above example will not work for nested types. If you wish to include them,
+    use reflection.MakeClass() instead of manually instantiating the class in
+    order to create the appropriate class structure.
+    """
+
+    # Must be consistent with the protocol-compiler code in
+    # proto2/compiler/internal/generator.*.
+    _DESCRIPTOR_KEY = 'DESCRIPTOR'
diff --git a/lark_channel/ws/pb/google/protobuf/pyext/descriptor.cc b/lark_channel/ws/pb/google/protobuf/pyext/descriptor.cc
new file mode 100644
index 0000000..1625312
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/pyext/descriptor.cc
@@ -0,0 +1,2040 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: petar@google.com (Petar Petrov)
+
+#include <google/protobuf/pyext/descriptor.h>
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include <frameobject.h>
+
+#include <cstdint>
+#include <string>
+#include <unordered_map>
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/descriptor.pb.h>
+#include <google/protobuf/dynamic_message.h>
+#include <google/protobuf/pyext/descriptor_containers.h>
+#include <google/protobuf/pyext/descriptor_pool.h>
+#include <google/protobuf/pyext/message.h>
+#include <google/protobuf/pyext/message_factory.h>
+#include <google/protobuf/pyext/scoped_pyobject_ptr.h>
+#include <google/protobuf/stubs/hash.h>
+
+#define PyString_AsStringAndSize(ob, charpp, sizep)              \
+  (PyUnicode_Check(ob)                                           \
+       ? ((*(charpp) = const_cast<char*>(                        \
+               PyUnicode_AsUTF8AndSize(ob, (sizep)))) == nullptr \
+              ? -1                                               \
+              : 0)                                               \
+       : PyBytes_AsStringAndSize(ob, (charpp), (sizep)))
+
+namespace google {
+namespace protobuf {
+namespace python {
+
+// Store interned descriptors, so that the same C++ descriptor yields the same
+// Python object. Objects are not immortal: this map does not own the
+// references, and items are deleted when the last reference to the object is
+// released.
+// This is enough to support the "is" operator on live objects.
+// All descriptors are stored here.
+std::unordered_map<const void*, PyObject*>* interned_descriptors;
+
+PyObject* PyString_FromCppString(const std::string& str) {
+  return PyUnicode_FromStringAndSize(str.c_str(), str.size());
+}
+
+// Check that the calling Python code is the global scope of a _pb2.py module.
+// This function is used to support the current code generated by the proto
+// compiler, which creates descriptors, then update some properties.
+// For example:
+//   message_descriptor = Descriptor(
+//       name='Message',
+//       fields = [FieldDescriptor(name='field')]
+//   message_descriptor.fields[0].containing_type = message_descriptor
+//
+// This code is still executed, but the descriptors now have no other storage
+// than the (const) C++ pointer, and are immutable.
+// So we let this code pass, by simply ignoring the new value.
+//
+// From user code, descriptors still look immutable.
+//
+// TODO(amauryfa): Change the proto2 compiler to remove the assignments, and
+// remove this hack.
+bool _CalledFromGeneratedFile(int stacklevel) {
+#ifndef PYPY_VERSION
+  // This check is not critical and is somewhat difficult to implement correctly
+  // in PyPy.
+  PyFrameObject* frame = PyEval_GetFrame();
+  if (frame == nullptr) {
+    return false;
+  }
+  while (stacklevel-- > 0) {
+    frame = frame->f_back;
+    if (frame == nullptr) {
+      return false;
+    }
+  }
+
+  if (frame->f_code->co_filename == nullptr) {
+    return false;
+  }
+  char* filename;
+  Py_ssize_t filename_size;
+  if (PyString_AsStringAndSize(frame->f_code->co_filename,
+                               &filename, &filename_size) < 0) {
+    // filename is not a string.
+    PyErr_Clear();
+    return false;
+  }
+  if ((filename_size < 3) ||
+      (strcmp(&filename[filename_size - 3], ".py") != 0)) {
+    // Cython's stack does not have .py file name and is not at global module
+    // scope.
+    return true;
+  }
+  if (filename_size < 7) {
+    // filename is too short.
+    return false;
+  }
+  if (strcmp(&filename[filename_size - 7], "_pb2.py") != 0) {
+    // Filename is not ending with _pb2.
+    return false;
+  }
+
+  if (frame->f_globals != frame->f_locals) {
+    // Not at global module scope
+    return false;
+  }
+#endif
+  return true;
+}
+
+// If the calling code is not a _pb2.py file, raise AttributeError.
+// To be used in attribute setters.
+static int CheckCalledFromGeneratedFile(const char* attr_name) {
+  if (_CalledFromGeneratedFile(0)) {
+    return 0;
+  }
+  PyErr_Format(PyExc_AttributeError,
+               "attribute is not writable: %s", attr_name);
+  return -1;
+}
+
+
+#ifndef PyVarObject_HEAD_INIT
+#define PyVarObject_HEAD_INIT(type, size) PyObject_HEAD_INIT(type) size,
+#endif
+#ifndef Py_TYPE
+#define Py_TYPE(ob) (((PyObject*)(ob))->ob_type)
+#endif
+
+
+// Helper functions for descriptor objects.
+
+// A set of templates to retrieve the C++ FileDescriptor of any descriptor.
+template<class DescriptorClass>
+const FileDescriptor* GetFileDescriptor(const DescriptorClass* descriptor) {
+  return descriptor->file();
+}
+template<>
+const FileDescriptor* GetFileDescriptor(const FileDescriptor* descriptor) {
+  return descriptor;
+}
+template<>
+const FileDescriptor* GetFileDescriptor(const EnumValueDescriptor* descriptor) {
+  return descriptor->type()->file();
+}
+template<>
+const FileDescriptor* GetFileDescriptor(const OneofDescriptor* descriptor) {
+  return descriptor->containing_type()->file();
+}
+template<>
+const FileDescriptor* GetFileDescriptor(const MethodDescriptor* descriptor) {
+  return descriptor->service()->file();
+}
+
+bool Reparse(
+    PyMessageFactory* message_factory, const Message& from, Message* to) {
+  // Reparse message.
+  std::string serialized;
+  from.SerializeToString(&serialized);
+  io::CodedInputStream input(
+      reinterpret_cast<const uint8_t*>(serialized.c_str()), serialized.size());
+  input.SetExtensionRegistry(message_factory->pool->pool,
+                             message_factory->message_factory);
+  bool success = to->ParseFromCodedStream(&input);
+  if (!success) {
+    return false;
+  }
+  return true;
+}
+// Converts options into a Python protobuf, and cache the result.
+//
+// This is a bit tricky because options can contain extension fields defined in
+// the same proto file. In this case the options parsed from the serialized_pb
+// have unknown fields, and we need to parse them again.
+//
+// Always returns a new reference.
+template<class DescriptorClass>
+static PyObject* GetOrBuildOptions(const DescriptorClass *descriptor) {
+  // Options are cached in the pool that owns the descriptor.
+  // First search in the cache.
+  PyDescriptorPool* caching_pool = GetDescriptorPool_FromPool(
+      GetFileDescriptor(descriptor)->pool());
+  std::unordered_map<const void*, PyObject*>* descriptor_options =
+      caching_pool->descriptor_options;
+  if (descriptor_options->find(descriptor) != descriptor_options->end()) {
+    PyObject *value = (*descriptor_options)[descriptor];
+    Py_INCREF(value);
+    return value;
+  }
+
+  // Similar to the C++ implementation, we return an Options object from the
+  // default (generated) factory, so that client code know that they can use
+  // extensions from generated files:
+  //    d.GetOptions().Extensions[some_pb2.extension]
+  //
+  // The consequence is that extensions not defined in the default pool won't
+  // be available.  If needed, we could add an optional 'message_factory'
+  // parameter to the GetOptions() function.
+  PyMessageFactory* message_factory =
+      GetDefaultDescriptorPool()->py_message_factory;
+
+  // Build the Options object: get its Python class, and make a copy of the C++
+  // read-only instance.
+  const Message& options(descriptor->options());
+  const Descriptor *message_type = options.GetDescriptor();
+  CMessageClass* message_class = message_factory::GetOrCreateMessageClass(
+      message_factory, message_type);
+  if (message_class == nullptr) {
+    PyErr_Format(PyExc_TypeError, "Could not retrieve class for Options: %s",
+                 message_type->full_name().c_str());
+    return nullptr;
+  }
+  ScopedPyObjectPtr args(PyTuple_New(0));
+  ScopedPyObjectPtr value(
+      PyObject_Call(message_class->AsPyObject(), args.get(), nullptr));
+  Py_DECREF(message_class);
+  if (value == nullptr) {
+    return nullptr;
+  }
+  if (!PyObject_TypeCheck(value.get(), CMessage_Type)) {
+      PyErr_Format(PyExc_TypeError, "Invalid class for %s: %s",
+                   message_type->full_name().c_str(),
+                   Py_TYPE(value.get())->tp_name);
+      return nullptr;
+  }
+  CMessage* cmsg = reinterpret_cast<CMessage*>(value.get());
+
+  const Reflection* reflection = options.GetReflection();
+  const UnknownFieldSet& unknown_fields(reflection->GetUnknownFields(options));
+  if (unknown_fields.empty()) {
+    cmsg->message->CopyFrom(options);
+  } else {
+    // Reparse options string!  XXX call cmessage::MergeFromString
+    if (!Reparse(message_factory, options, cmsg->message)) {
+      PyErr_Format(PyExc_ValueError, "Error reparsing Options message");
+      return nullptr;
+    }
+  }
+
+  // Cache the result.
+  Py_INCREF(value.get());
+  (*descriptor_options)[descriptor] = value.get();
+
+  return value.release();
+}
+
+// Copy the C++ descriptor to a Python message.
+// The Python message is an instance of descriptor_pb2.DescriptorProto
+// or similar.
+template<class DescriptorProtoClass, class DescriptorClass>
+static PyObject* CopyToPythonProto(const DescriptorClass *descriptor,
+                                   PyObject *target) {
+  const Descriptor* self_descriptor =
+      DescriptorProtoClass::default_instance().GetDescriptor();
+  CMessage* message = reinterpret_cast<CMessage*>(target);
+  if (!PyObject_TypeCheck(target, CMessage_Type) ||
+      message->message->GetDescriptor() != self_descriptor) {
+    PyErr_Format(PyExc_TypeError, "Not a %s message",
+                 self_descriptor->full_name().c_str());
+    return nullptr;
+  }
+  cmessage::AssureWritable(message);
+  DescriptorProtoClass* descriptor_message =
+      static_cast<DescriptorProtoClass*>(message->message);
+  descriptor->CopyTo(descriptor_message);
+  // Custom options might in unknown extensions. Reparse
+  // the descriptor_message. Can't skip reparse when options unknown
+  // fields is empty, because they might in sub descriptors' options.
+  PyMessageFactory* message_factory =
+      GetDefaultDescriptorPool()->py_message_factory;
+  if (!Reparse(message_factory, *descriptor_message, descriptor_message)) {
+    PyErr_Format(PyExc_ValueError, "Error reparsing descriptor message");
+    return nullptr;
+  }
+
+  Py_RETURN_NONE;
+}
+
+// All Descriptors classes share the same memory layout.
+typedef struct PyBaseDescriptor {
+  PyObject_HEAD
+
+  // Pointer to the C++ proto2 descriptor.
+  // Like all descriptors, it is owned by the global DescriptorPool.
+  const void* descriptor;
+
+  // Owned reference to the DescriptorPool, to ensure it is kept alive.
+  PyDescriptorPool* pool;
+} PyBaseDescriptor;
+
+
+// FileDescriptor structure "inherits" from the base descriptor.
+typedef struct PyFileDescriptor {
+  PyBaseDescriptor base;
+
+  // The cached version of serialized pb. Either null, or a Bytes string.
+  // We own the reference.
+  PyObject *serialized_pb;
+} PyFileDescriptor;
+
+
+namespace descriptor {
+
+// Creates or retrieve a Python descriptor of the specified type.
+// Objects are interned: the same descriptor will return the same object if it
+// was kept alive.
+// 'was_created' is an optional pointer to a bool, and is set to true if a new
+// object was allocated.
+// Always return a new reference.
+template<class DescriptorClass>
+PyObject* NewInternedDescriptor(PyTypeObject* type,
+                                const DescriptorClass* descriptor,
+                                bool* was_created) {
+  if (was_created) {
+    *was_created = false;
+  }
+  if (descriptor == nullptr) {
+    PyErr_BadInternalCall();
+    return nullptr;
+  }
+
+  // See if the object is in the map of interned descriptors
+  std::unordered_map<const void*, PyObject*>::iterator it =
+      interned_descriptors->find(descriptor);
+  if (it != interned_descriptors->end()) {
+    GOOGLE_DCHECK(Py_TYPE(it->second) == type);
+    Py_INCREF(it->second);
+    return it->second;
+  }
+  // Create a new descriptor object
+  PyBaseDescriptor* py_descriptor = PyObject_GC_New(
+      PyBaseDescriptor, type);
+  if (py_descriptor == nullptr) {
+    return nullptr;
+  }
+  py_descriptor->descriptor = descriptor;
+
+  // and cache it.
+  interned_descriptors->insert(
+      std::make_pair(descriptor, reinterpret_cast<PyObject*>(py_descriptor)));
+
+  // Ensures that the DescriptorPool stays alive.
+  PyDescriptorPool* pool = GetDescriptorPool_FromPool(
+      GetFileDescriptor(descriptor)->pool());
+  if (pool == nullptr) {
+    // Don't DECREF, the object is not fully initialized.
+    PyObject_Del(py_descriptor);
+    return nullptr;
+  }
+  Py_INCREF(pool);
+  py_descriptor->pool = pool;
+
+  PyObject_GC_Track(py_descriptor);
+
+  if (was_created) {
+    *was_created = true;
+  }
+  return reinterpret_cast<PyObject*>(py_descriptor);
+}
+
+static void Dealloc(PyObject* pself) {
+  PyBaseDescriptor* self = reinterpret_cast<PyBaseDescriptor*>(pself);
+  // Remove from interned dictionary
+  interned_descriptors->erase(self->descriptor);
+  Py_CLEAR(self->pool);
+  Py_TYPE(self)->tp_free(pself);
+}
+
+static int GcTraverse(PyObject* pself, visitproc visit, void* arg) {
+  PyBaseDescriptor* self = reinterpret_cast<PyBaseDescriptor*>(pself);
+  Py_VISIT(self->pool);
+  return 0;
+}
+
+static int GcClear(PyObject* pself) {
+  PyBaseDescriptor* self = reinterpret_cast<PyBaseDescriptor*>(pself);
+  Py_CLEAR(self->pool);
+  return 0;
+}
+
+static PyGetSetDef Getters[] = {
+    {nullptr},
+};
+
+PyTypeObject PyBaseDescriptor_Type = {
+    PyVarObject_HEAD_INIT(&PyType_Type, 0) FULL_MODULE_NAME
+    ".DescriptorBase",         // tp_name
+    sizeof(PyBaseDescriptor),  // tp_basicsize
+    0,                         // tp_itemsize
+    (destructor)Dealloc,       // tp_dealloc
+#if PY_VERSION_HEX < 0x03080000
+    nullptr,  // tp_print
+#else
+    0,  // tp_vectorcall_offset
+#endif
+    nullptr,                                  // tp_getattr
+    nullptr,                                  // tp_setattr
+    nullptr,                                  // tp_compare
+    nullptr,                                  // tp_repr
+    nullptr,                                  // tp_as_number
+    nullptr,                                  // tp_as_sequence
+    nullptr,                                  // tp_as_mapping
+    nullptr,                                  // tp_hash
+    nullptr,                                  // tp_call
+    nullptr,                                  // tp_str
+    nullptr,                                  // tp_getattro
+    nullptr,                                  // tp_setattro
+    nullptr,                                  // tp_as_buffer
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,  // tp_flags
+    "Descriptors base class",                 // tp_doc
+    GcTraverse,                               // tp_traverse
+    GcClear,                                  // tp_clear
+    nullptr,                                  // tp_richcompare
+    0,                                        // tp_weaklistoffset
+    nullptr,                                  // tp_iter
+    nullptr,                                  // tp_iternext
+    nullptr,                                  // tp_methods
+    nullptr,                                  // tp_members
+    Getters,                                  // tp_getset
+};
+
+}  // namespace descriptor
+
+const void* PyDescriptor_AsVoidPtr(PyObject* obj) {
+  if (!PyObject_TypeCheck(obj, &descriptor::PyBaseDescriptor_Type)) {
+    PyErr_SetString(PyExc_TypeError, "Not a BaseDescriptor");
+    return nullptr;
+  }
+  return reinterpret_cast<PyBaseDescriptor*>(obj)->descriptor;
+}
+
+namespace message_descriptor {
+
+// Unchecked accessor to the C++ pointer.
+static const Descriptor* _GetDescriptor(PyBaseDescriptor* self) {
+  return reinterpret_cast<const Descriptor*>(self->descriptor);
+}
+
+static PyObject* GetName(PyBaseDescriptor* self, void *closure) {
+  return PyString_FromCppString(_GetDescriptor(self)->name());
+}
+
+static PyObject* GetFullName(PyBaseDescriptor* self, void *closure) {
+  return PyString_FromCppString(_GetDescriptor(self)->full_name());
+}
+
+static PyObject* GetFile(PyBaseDescriptor *self, void *closure) {
+  return PyFileDescriptor_FromDescriptor(_GetDescriptor(self)->file());
+}
+
+static PyObject* GetConcreteClass(PyBaseDescriptor* self, void *closure) {
+  // Returns the canonical class for the given descriptor.
+  // This is the class that was registered with the primary descriptor pool
+  // which contains this descriptor.
+  // This might not be the one you expect! For example the returned object does
+  // not know about extensions defined in a custom pool.
+  CMessageClass* concrete_class(message_factory::GetMessageClass(
+      GetDescriptorPool_FromPool(
+          _GetDescriptor(self)->file()->pool())->py_message_factory,
+      _GetDescriptor(self)));
+  Py_XINCREF(concrete_class);
+  return concrete_class->AsPyObject();
+}
+
+static PyObject* GetFieldsByName(PyBaseDescriptor* self, void *closure) {
+  return NewMessageFieldsByName(_GetDescriptor(self));
+}
+
+static PyObject* GetFieldsByCamelcaseName(PyBaseDescriptor* self,
+                                          void *closure) {
+  return NewMessageFieldsByCamelcaseName(_GetDescriptor(self));
+}
+
+static PyObject* GetFieldsByNumber(PyBaseDescriptor* self, void *closure) {
+  return NewMessageFieldsByNumber(_GetDescriptor(self));
+}
+
+static PyObject* GetFieldsSeq(PyBaseDescriptor* self, void *closure) {
+  return NewMessageFieldsSeq(_GetDescriptor(self));
+}
+
+static PyObject* GetNestedTypesByName(PyBaseDescriptor* self, void *closure) {
+  return NewMessageNestedTypesByName(_GetDescriptor(self));
+}
+
+static PyObject* GetNestedTypesSeq(PyBaseDescriptor* self, void *closure) {
+  return NewMessageNestedTypesSeq(_GetDescriptor(self));
+}
+
+static PyObject* GetExtensionsByName(PyBaseDescriptor* self, void *closure) {
+  return NewMessageExtensionsByName(_GetDescriptor(self));
+}
+
+static PyObject* GetExtensions(PyBaseDescriptor* self, void *closure) {
+  return NewMessageExtensionsSeq(_GetDescriptor(self));
+}
+
+static PyObject* GetEnumsSeq(PyBaseDescriptor* self, void *closure) {
+  return NewMessageEnumsSeq(_GetDescriptor(self));
+}
+
+static PyObject* GetEnumTypesByName(PyBaseDescriptor* self, void *closure) {
+  return NewMessageEnumsByName(_GetDescriptor(self));
+}
+
+static PyObject* GetEnumValuesByName(PyBaseDescriptor* self, void *closure) {
+  return NewMessageEnumValuesByName(_GetDescriptor(self));
+}
+
+static PyObject* GetOneofsByName(PyBaseDescriptor* self, void *closure) {
+  return NewMessageOneofsByName(_GetDescriptor(self));
+}
+
+static PyObject* GetOneofsSeq(PyBaseDescriptor* self, void *closure) {
+  return NewMessageOneofsSeq(_GetDescriptor(self));
+}
+
+static PyObject* IsExtendable(PyBaseDescriptor *self, void *closure) {
+  if (_GetDescriptor(self)->extension_range_count() > 0) {
+    Py_RETURN_TRUE;
+  } else {
+    Py_RETURN_FALSE;
+  }
+}
+
+static PyObject* GetExtensionRanges(PyBaseDescriptor *self, void *closure) {
+  const Descriptor* descriptor = _GetDescriptor(self);
+  PyObject* range_list = PyList_New(descriptor->extension_range_count());
+
+  for (int i = 0; i < descriptor->extension_range_count(); i++) {
+    const Descriptor::ExtensionRange* range = descriptor->extension_range(i);
+    PyObject* start = PyLong_FromLong(range->start);
+    PyObject* end = PyLong_FromLong(range->end);
+    PyList_SetItem(range_list, i, PyTuple_Pack(2, start, end));
+  }
+
+  return range_list;
+}
+
+static PyObject* GetContainingType(PyBaseDescriptor *self, void *closure) {
+  const Descriptor* containing_type =
+      _GetDescriptor(self)->containing_type();
+  if (containing_type) {
+    return PyMessageDescriptor_FromDescriptor(containing_type);
+  } else {
+    Py_RETURN_NONE;
+  }
+}
+
+static int SetContainingType(PyBaseDescriptor *self, PyObject *value,
+                             void *closure) {
+  return CheckCalledFromGeneratedFile("containing_type");
+}
+
+static PyObject* GetHasOptions(PyBaseDescriptor *self, void *closure) {
+  const MessageOptions& options(_GetDescriptor(self)->options());
+  if (&options != &MessageOptions::default_instance()) {
+    Py_RETURN_TRUE;
+  } else {
+    Py_RETURN_FALSE;
+  }
+}
+static int SetHasOptions(PyBaseDescriptor *self, PyObject *value,
+                             void *closure) {
+  return CheckCalledFromGeneratedFile("has_options");
+}
+
+static PyObject* GetOptions(PyBaseDescriptor *self) {
+  return GetOrBuildOptions(_GetDescriptor(self));
+}
+
+static int SetOptions(PyBaseDescriptor *self, PyObject *value,
+                      void *closure) {
+  return CheckCalledFromGeneratedFile("_options");
+}
+
+static int SetSerializedOptions(PyBaseDescriptor *self, PyObject *value,
+                                void *closure) {
+  return CheckCalledFromGeneratedFile("_serialized_options");
+}
+
+static PyObject* CopyToProto(PyBaseDescriptor *self, PyObject *target) {
+  return CopyToPythonProto<DescriptorProto>(_GetDescriptor(self), target);
+}
+
+static PyObject* EnumValueName(PyBaseDescriptor *self, PyObject *args) {
+  const char *enum_name;
+  int number;
+  if (!PyArg_ParseTuple(args, "si", &enum_name, &number)) return nullptr;
+  const EnumDescriptor *enum_type =
+      _GetDescriptor(self)->FindEnumTypeByName(enum_name);
+  if (enum_type == nullptr) {
+    PyErr_SetString(PyExc_KeyError, enum_name);
+    return nullptr;
+  }
+  const EnumValueDescriptor *enum_value =
+      enum_type->FindValueByNumber(number);
+  if (enum_value == nullptr) {
+    PyErr_Format(PyExc_KeyError, "%d", number);
+    return nullptr;
+  }
+  return PyString_FromCppString(enum_value->name());
+}
+
+static PyObject* GetSyntax(PyBaseDescriptor *self, void *closure) {
+  return PyUnicode_InternFromString(
+      FileDescriptor::SyntaxName(_GetDescriptor(self)->file()->syntax()));
+}
+
+static PyGetSetDef Getters[] = {
+    {"name", (getter)GetName, nullptr, "Last name"},
+    {"full_name", (getter)GetFullName, nullptr, "Full name"},
+    {"_concrete_class", (getter)GetConcreteClass, nullptr, "concrete class"},
+    {"file", (getter)GetFile, nullptr, "File descriptor"},
+
+    {"fields", (getter)GetFieldsSeq, nullptr, "Fields sequence"},
+    {"fields_by_name", (getter)GetFieldsByName, nullptr, "Fields by name"},
+    {"fields_by_camelcase_name", (getter)GetFieldsByCamelcaseName, nullptr,
+     "Fields by camelCase name"},
+    {"fields_by_number", (getter)GetFieldsByNumber, nullptr,
+     "Fields by number"},
+    {"nested_types", (getter)GetNestedTypesSeq, nullptr,
+     "Nested types sequence"},
+    {"nested_types_by_name", (getter)GetNestedTypesByName, nullptr,
+     "Nested types by name"},
+    {"extensions", (getter)GetExtensions, nullptr, "Extensions Sequence"},
+    {"extensions_by_name", (getter)GetExtensionsByName, nullptr,
+     "Extensions by name"},
+    {"extension_ranges", (getter)GetExtensionRanges, nullptr,
+     "Extension ranges"},
+    {"enum_types", (getter)GetEnumsSeq, nullptr, "Enum sequence"},
+    {"enum_types_by_name", (getter)GetEnumTypesByName, nullptr,
+     "Enum types by name"},
+    {"enum_values_by_name", (getter)GetEnumValuesByName, nullptr,
+     "Enum values by name"},
+    {"oneofs_by_name", (getter)GetOneofsByName, nullptr, "Oneofs by name"},
+    {"oneofs", (getter)GetOneofsSeq, nullptr, "Oneofs by name"},
+    {"containing_type", (getter)GetContainingType, (setter)SetContainingType,
+     "Containing type"},
+    {"is_extendable", (getter)IsExtendable, (setter) nullptr},
+    {"has_options", (getter)GetHasOptions, (setter)SetHasOptions,
+     "Has Options"},
+    {"_options", (getter) nullptr, (setter)SetOptions, "Options"},
+    {"_serialized_options", (getter) nullptr, (setter)SetSerializedOptions,
+     "Serialized Options"},
+    {"syntax", (getter)GetSyntax, (setter) nullptr, "Syntax"},
+    {nullptr},
+};
+
+static PyMethodDef Methods[] = {
+    {"GetOptions", (PyCFunction)GetOptions, METH_NOARGS},
+    {"CopyToProto", (PyCFunction)CopyToProto, METH_O},
+    {"EnumValueName", (PyCFunction)EnumValueName, METH_VARARGS},
+    {nullptr},
+};
+
+}  // namespace message_descriptor
+
+PyTypeObject PyMessageDescriptor_Type = {
+    PyVarObject_HEAD_INIT(&PyType_Type, 0) FULL_MODULE_NAME
+    ".MessageDescriptor",      // tp_name
+    sizeof(PyBaseDescriptor),  // tp_basicsize
+    0,                         // tp_itemsize
+    nullptr,                   // tp_dealloc
+#if PY_VERSION_HEX < 0x03080000
+    nullptr,  // tp_print
+#else
+    0,  // tp_vectorcall_offset
+#endif
+    nullptr,                             // tp_getattr
+    nullptr,                             // tp_setattr
+    nullptr,                             // tp_compare
+    nullptr,                             // tp_repr
+    nullptr,                             // tp_as_number
+    nullptr,                             // tp_as_sequence
+    nullptr,                             // tp_as_mapping
+    nullptr,                             // tp_hash
+    nullptr,                             // tp_call
+    nullptr,                             // tp_str
+    nullptr,                             // tp_getattro
+    nullptr,                             // tp_setattro
+    nullptr,                             // tp_as_buffer
+    Py_TPFLAGS_DEFAULT,                  // tp_flags
+    "A Message Descriptor",              // tp_doc
+    nullptr,                             // tp_traverse
+    nullptr,                             // tp_clear
+    nullptr,                             // tp_richcompare
+    0,                                   // tp_weaklistoffset
+    nullptr,                             // tp_iter
+    nullptr,                             // tp_iternext
+    message_descriptor::Methods,         // tp_methods
+    nullptr,                             // tp_members
+    message_descriptor::Getters,         // tp_getset
+    &descriptor::PyBaseDescriptor_Type,  // tp_base
+};
+
+PyObject* PyMessageDescriptor_FromDescriptor(
+    const Descriptor* message_descriptor) {
+  return descriptor::NewInternedDescriptor(&PyMessageDescriptor_Type,
+                                           message_descriptor, nullptr);
+}
+
+const Descriptor* PyMessageDescriptor_AsDescriptor(PyObject* obj) {
+  if (!PyObject_TypeCheck(obj, &PyMessageDescriptor_Type)) {
+    PyErr_SetString(PyExc_TypeError, "Not a MessageDescriptor");
+    return nullptr;
+  }
+  return reinterpret_cast<const Descriptor*>(
+      reinterpret_cast<PyBaseDescriptor*>(obj)->descriptor);
+}
+
+namespace field_descriptor {
+
+// Unchecked accessor to the C++ pointer.
+static const FieldDescriptor* _GetDescriptor(
+    PyBaseDescriptor *self) {
+  return reinterpret_cast<const FieldDescriptor*>(self->descriptor);
+}
+
+static PyObject* GetFullName(PyBaseDescriptor* self, void *closure) {
+  return PyString_FromCppString(_GetDescriptor(self)->full_name());
+}
+
+static PyObject* GetName(PyBaseDescriptor *self, void *closure) {
+  return PyString_FromCppString(_GetDescriptor(self)->name());
+}
+
+static PyObject* GetCamelcaseName(PyBaseDescriptor* self, void *closure) {
+  return PyString_FromCppString(_GetDescriptor(self)->camelcase_name());
+}
+
+static PyObject* GetJsonName(PyBaseDescriptor* self, void *closure) {
+  return PyString_FromCppString(_GetDescriptor(self)->json_name());
+}
+
+static PyObject* GetFile(PyBaseDescriptor *self, void *closure) {
+  return PyFileDescriptor_FromDescriptor(_GetDescriptor(self)->file());
+}
+
+static PyObject* GetType(PyBaseDescriptor *self, void *closure) {
+  return PyLong_FromLong(_GetDescriptor(self)->type());
+}
+
+static PyObject* GetCppType(PyBaseDescriptor *self, void *closure) {
+  return PyLong_FromLong(_GetDescriptor(self)->cpp_type());
+}
+
+static PyObject* GetLabel(PyBaseDescriptor *self, void *closure) {
+  return PyLong_FromLong(_GetDescriptor(self)->label());
+}
+
+static PyObject* GetNumber(PyBaseDescriptor *self, void *closure) {
+  return PyLong_FromLong(_GetDescriptor(self)->number());
+}
+
+static PyObject* GetIndex(PyBaseDescriptor *self, void *closure) {
+  return PyLong_FromLong(_GetDescriptor(self)->index());
+}
+
+static PyObject* GetID(PyBaseDescriptor *self, void *closure) {
+  return PyLong_FromVoidPtr(self);
+}
+
+static PyObject* IsExtension(PyBaseDescriptor *self, void *closure) {
+  return PyBool_FromLong(_GetDescriptor(self)->is_extension());
+}
+
+static PyObject* HasDefaultValue(PyBaseDescriptor *self, void *closure) {
+  return PyBool_FromLong(_GetDescriptor(self)->has_default_value());
+}
+
+static PyObject* GetDefaultValue(PyBaseDescriptor *self, void *closure) {
+  PyObject *result;
+
+  if (_GetDescriptor(self)->is_repeated()) {
+    return PyList_New(0);
+  }
+
+
+  switch (_GetDescriptor(self)->cpp_type()) {
+    case FieldDescriptor::CPPTYPE_INT32: {
+      int32_t value = _GetDescriptor(self)->default_value_int32();
+      result = PyLong_FromLong(value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_INT64: {
+      int64_t value = _GetDescriptor(self)->default_value_int64();
+      result = PyLong_FromLongLong(value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_UINT32: {
+      uint32_t value = _GetDescriptor(self)->default_value_uint32();
+      result = PyLong_FromSsize_t(value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_UINT64: {
+      uint64_t value = _GetDescriptor(self)->default_value_uint64();
+      result = PyLong_FromUnsignedLongLong(value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_FLOAT: {
+      float value = _GetDescriptor(self)->default_value_float();
+      result = PyFloat_FromDouble(value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_DOUBLE: {
+      double value = _GetDescriptor(self)->default_value_double();
+      result = PyFloat_FromDouble(value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_BOOL: {
+      bool value = _GetDescriptor(self)->default_value_bool();
+      result = PyBool_FromLong(value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_STRING: {
+      const std::string& value = _GetDescriptor(self)->default_value_string();
+      result = ToStringObject(_GetDescriptor(self), value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_ENUM: {
+      const EnumValueDescriptor* value =
+          _GetDescriptor(self)->default_value_enum();
+      result = PyLong_FromLong(value->number());
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_MESSAGE: {
+      Py_RETURN_NONE;
+      break;
+    }
+    default:
+      PyErr_Format(PyExc_NotImplementedError, "default value for %s",
+                   _GetDescriptor(self)->full_name().c_str());
+      return nullptr;
+  }
+  return result;
+}
+
+static PyObject* GetCDescriptor(PyObject *self, void *closure) {
+  Py_INCREF(self);
+  return self;
+}
+
+static PyObject *GetEnumType(PyBaseDescriptor *self, void *closure) {
+  const EnumDescriptor* enum_type = _GetDescriptor(self)->enum_type();
+  if (enum_type) {
+    return PyEnumDescriptor_FromDescriptor(enum_type);
+  } else {
+    Py_RETURN_NONE;
+  }
+}
+
+static int SetEnumType(PyBaseDescriptor *self, PyObject *value, void *closure) {
+  return CheckCalledFromGeneratedFile("enum_type");
+}
+
+static PyObject *GetMessageType(PyBaseDescriptor *self, void *closure) {
+  const Descriptor* message_type = _GetDescriptor(self)->message_type();
+  if (message_type) {
+    return PyMessageDescriptor_FromDescriptor(message_type);
+  } else {
+    Py_RETURN_NONE;
+  }
+}
+
+static int SetMessageType(PyBaseDescriptor *self, PyObject *value,
+                          void *closure) {
+  return CheckCalledFromGeneratedFile("message_type");
+}
+
+static PyObject* GetContainingType(PyBaseDescriptor *self, void *closure) {
+  const Descriptor* containing_type =
+      _GetDescriptor(self)->containing_type();
+  if (containing_type) {
+    return PyMessageDescriptor_FromDescriptor(containing_type);
+  } else {
+    Py_RETURN_NONE;
+  }
+}
+
+static int SetContainingType(PyBaseDescriptor *self, PyObject *value,
+                             void *closure) {
+  return CheckCalledFromGeneratedFile("containing_type");
+}
+
+static PyObject* GetExtensionScope(PyBaseDescriptor *self, void *closure) {
+  const auto* desc = _GetDescriptor(self);
+  const Descriptor* extension_scope =
+      desc->is_extension() ? desc->extension_scope() : nullptr;
+  if (extension_scope) {
+    return PyMessageDescriptor_FromDescriptor(extension_scope);
+  } else {
+    Py_RETURN_NONE;
+  }
+}
+
+static PyObject* GetContainingOneof(PyBaseDescriptor *self, void *closure) {
+  const OneofDescriptor* containing_oneof =
+      _GetDescriptor(self)->containing_oneof();
+  if (containing_oneof) {
+    return PyOneofDescriptor_FromDescriptor(containing_oneof);
+  } else {
+    Py_RETURN_NONE;
+  }
+}
+
+static int SetContainingOneof(PyBaseDescriptor *self, PyObject *value,
+                              void *closure) {
+  return CheckCalledFromGeneratedFile("containing_oneof");
+}
+
+static PyObject* GetHasOptions(PyBaseDescriptor *self, void *closure) {
+  const FieldOptions& options(_GetDescriptor(self)->options());
+  if (&options != &FieldOptions::default_instance()) {
+    Py_RETURN_TRUE;
+  } else {
+    Py_RETURN_FALSE;
+  }
+}
+static int SetHasOptions(PyBaseDescriptor *self, PyObject *value,
+                         void *closure) {
+  return CheckCalledFromGeneratedFile("has_options");
+}
+
+static PyObject* GetHasPresence(PyBaseDescriptor* self, void* closure) {
+  if (_GetDescriptor(self)->has_presence()) {
+    Py_RETURN_TRUE;
+  } else {
+    Py_RETURN_FALSE;
+  }
+}
+
+static PyObject* GetOptions(PyBaseDescriptor *self) {
+  return GetOrBuildOptions(_GetDescriptor(self));
+}
+
+static int SetOptions(PyBaseDescriptor *self, PyObject *value,
+                      void *closure) {
+  return CheckCalledFromGeneratedFile("_options");
+}
+
+static int SetSerializedOptions(PyBaseDescriptor *self, PyObject *value,
+                                void *closure) {
+  return CheckCalledFromGeneratedFile("_serialized_options");
+}
+
+static PyGetSetDef Getters[] = {
+    {"full_name", (getter)GetFullName, nullptr, "Full name"},
+    {"name", (getter)GetName, nullptr, "Unqualified name"},
+    {"camelcase_name", (getter)GetCamelcaseName, nullptr, "Camelcase name"},
+    {"json_name", (getter)GetJsonName, nullptr, "Json name"},
+    {"file", (getter)GetFile, nullptr, "File Descriptor"},
+    {"type", (getter)GetType, nullptr, "C++ Type"},
+    {"cpp_type", (getter)GetCppType, nullptr, "C++ Type"},
+    {"label", (getter)GetLabel, nullptr, "Label"},
+    {"number", (getter)GetNumber, nullptr, "Number"},
+    {"index", (getter)GetIndex, nullptr, "Index"},
+    {"default_value", (getter)GetDefaultValue, nullptr, "Default Value"},
+    {"has_default_value", (getter)HasDefaultValue},
+    {"is_extension", (getter)IsExtension, nullptr, "ID"},
+    {"id", (getter)GetID, nullptr, "ID"},
+    {"_cdescriptor", (getter)GetCDescriptor, nullptr, "HAACK REMOVE ME"},
+
+    {"message_type", (getter)GetMessageType, (setter)SetMessageType,
+     "Message type"},
+    {"enum_type", (getter)GetEnumType, (setter)SetEnumType, "Enum type"},
+    {"containing_type", (getter)GetContainingType, (setter)SetContainingType,
+     "Containing type"},
+    {"extension_scope", (getter)GetExtensionScope, (setter) nullptr,
+     "Extension scope"},
+    {"containing_oneof", (getter)GetContainingOneof, (setter)SetContainingOneof,
+     "Containing oneof"},
+    {"has_options", (getter)GetHasOptions, (setter)SetHasOptions,
+     "Has Options"},
+    {"has_presence", (getter)GetHasPresence, (setter) nullptr, "Has Presence"},
+    {"_options", (getter) nullptr, (setter)SetOptions, "Options"},
+    {"_serialized_options", (getter) nullptr, (setter)SetSerializedOptions,
+     "Serialized Options"},
+    {nullptr},
+};
+
+static PyMethodDef Methods[] = {
+    {"GetOptions", (PyCFunction)GetOptions, METH_NOARGS},
+    {nullptr},
+};
+
+}  // namespace field_descriptor
+
+PyTypeObject PyFieldDescriptor_Type = {
+    PyVarObject_HEAD_INIT(&PyType_Type, 0) FULL_MODULE_NAME
+    ".FieldDescriptor",        // tp_name
+    sizeof(PyBaseDescriptor),  // tp_basicsize
+    0,                         // tp_itemsize
+    nullptr,                   // tp_dealloc
+#if PY_VERSION_HEX < 0x03080000
+    nullptr,  // tp_print
+#else
+    0,  // tp_vectorcall_offset
+#endif
+    nullptr,                             // tp_getattr
+    nullptr,                             // tp_setattr
+    nullptr,                             // tp_compare
+    nullptr,                             // tp_repr
+    nullptr,                             // tp_as_number
+    nullptr,                             // tp_as_sequence
+    nullptr,                             // tp_as_mapping
+    nullptr,                             // tp_hash
+    nullptr,                             // tp_call
+    nullptr,                             // tp_str
+    nullptr,                             // tp_getattro
+    nullptr,                             // tp_setattro
+    nullptr,                             // tp_as_buffer
+    Py_TPFLAGS_DEFAULT,                  // tp_flags
+    "A Field Descriptor",                // tp_doc
+    nullptr,                             // tp_traverse
+    nullptr,                             // tp_clear
+    nullptr,                             // tp_richcompare
+    0,                                   // tp_weaklistoffset
+    nullptr,                             // tp_iter
+    nullptr,                             // tp_iternext
+    field_descriptor::Methods,           // tp_methods
+    nullptr,                             // tp_members
+    field_descriptor::Getters,           // tp_getset
+    &descriptor::PyBaseDescriptor_Type,  // tp_base
+};
+
+PyObject* PyFieldDescriptor_FromDescriptor(
+    const FieldDescriptor* field_descriptor) {
+  return descriptor::NewInternedDescriptor(&PyFieldDescriptor_Type,
+                                           field_descriptor, nullptr);
+}
+
+const FieldDescriptor* PyFieldDescriptor_AsDescriptor(PyObject* obj) {
+  if (!PyObject_TypeCheck(obj, &PyFieldDescriptor_Type)) {
+    PyErr_SetString(PyExc_TypeError, "Not a FieldDescriptor");
+    return nullptr;
+  }
+  return reinterpret_cast<const FieldDescriptor*>(
+      reinterpret_cast<PyBaseDescriptor*>(obj)->descriptor);
+}
+
+namespace enum_descriptor {
+
+// Unchecked accessor to the C++ pointer.
+static const EnumDescriptor* _GetDescriptor(
+    PyBaseDescriptor *self) {
+  return reinterpret_cast<const EnumDescriptor*>(self->descriptor);
+}
+
+static PyObject* GetFullName(PyBaseDescriptor* self, void *closure) {
+  return PyString_FromCppString(_GetDescriptor(self)->full_name());
+}
+
+static PyObject* GetName(PyBaseDescriptor *self, void *closure) {
+  return PyString_FromCppString(_GetDescriptor(self)->name());
+}
+
+static PyObject* GetFile(PyBaseDescriptor *self, void *closure) {
+  return PyFileDescriptor_FromDescriptor(_GetDescriptor(self)->file());
+}
+
+static PyObject* GetEnumvaluesByName(PyBaseDescriptor* self, void *closure) {
+  return NewEnumValuesByName(_GetDescriptor(self));
+}
+
+static PyObject* GetEnumvaluesByNumber(PyBaseDescriptor* self, void *closure) {
+  return NewEnumValuesByNumber(_GetDescriptor(self));
+}
+
+static PyObject* GetEnumvaluesSeq(PyBaseDescriptor* self, void *closure) {
+  return NewEnumValuesSeq(_GetDescriptor(self));
+}
+
+static PyObject* GetContainingType(PyBaseDescriptor *self, void *closure) {
+  const Descriptor* containing_type =
+      _GetDescriptor(self)->containing_type();
+  if (containing_type) {
+    return PyMessageDescriptor_FromDescriptor(containing_type);
+  } else {
+    Py_RETURN_NONE;
+  }
+}
+
+static int SetContainingType(PyBaseDescriptor *self, PyObject *value,
+                             void *closure) {
+  return CheckCalledFromGeneratedFile("containing_type");
+}
+
+
+static PyObject* GetHasOptions(PyBaseDescriptor *self, void *closure) {
+  const EnumOptions& options(_GetDescriptor(self)->options());
+  if (&options != &EnumOptions::default_instance()) {
+    Py_RETURN_TRUE;
+  } else {
+    Py_RETURN_FALSE;
+  }
+}
+static int SetHasOptions(PyBaseDescriptor *self, PyObject *value,
+                         void *closure) {
+  return CheckCalledFromGeneratedFile("has_options");
+}
+
+static PyObject* GetOptions(PyBaseDescriptor *self) {
+  return GetOrBuildOptions(_GetDescriptor(self));
+}
+
+static int SetOptions(PyBaseDescriptor *self, PyObject *value,
+                      void *closure) {
+  return CheckCalledFromGeneratedFile("_options");
+}
+
+static int SetSerializedOptions(PyBaseDescriptor *self, PyObject *value,
+                                void *closure) {
+  return CheckCalledFromGeneratedFile("_serialized_options");
+}
+
+static PyObject* CopyToProto(PyBaseDescriptor *self, PyObject *target) {
+  return CopyToPythonProto<EnumDescriptorProto>(_GetDescriptor(self), target);
+}
+
+static PyMethodDef Methods[] = {
+    {"GetOptions", (PyCFunction)GetOptions, METH_NOARGS},
+    {"CopyToProto", (PyCFunction)CopyToProto, METH_O},
+    {nullptr},
+};
+
+static PyGetSetDef Getters[] = {
+    {"full_name", (getter)GetFullName, nullptr, "Full name"},
+    {"name", (getter)GetName, nullptr, "last name"},
+    {"file", (getter)GetFile, nullptr, "File descriptor"},
+    {"values", (getter)GetEnumvaluesSeq, nullptr, "values"},
+    {"values_by_name", (getter)GetEnumvaluesByName, nullptr,
+     "Enum values by name"},
+    {"values_by_number", (getter)GetEnumvaluesByNumber, nullptr,
+     "Enum values by number"},
+
+    {"containing_type", (getter)GetContainingType, (setter)SetContainingType,
+     "Containing type"},
+    {"has_options", (getter)GetHasOptions, (setter)SetHasOptions,
+     "Has Options"},
+    {"_options", (getter) nullptr, (setter)SetOptions, "Options"},
+    {"_serialized_options", (getter) nullptr, (setter)SetSerializedOptions,
+     "Serialized Options"},
+    {nullptr},
+};
+
+}  // namespace enum_descriptor
+
+PyTypeObject PyEnumDescriptor_Type = {
+    PyVarObject_HEAD_INIT(&PyType_Type, 0) FULL_MODULE_NAME
+    ".EnumDescriptor",         // tp_name
+    sizeof(PyBaseDescriptor),  // tp_basicsize
+    0,                         // tp_itemsize
+    nullptr,                   // tp_dealloc
+#if PY_VERSION_HEX < 0x03080000
+    nullptr,  // tp_print
+#else
+    0,  // tp_vectorcall_offset
+#endif
+    nullptr,                             // tp_getattr
+    nullptr,                             // tp_setattr
+    nullptr,                             // tp_compare
+    nullptr,                             // tp_repr
+    nullptr,                             // tp_as_number
+    nullptr,                             // tp_as_sequence
+    nullptr,                             // tp_as_mapping
+    nullptr,                             // tp_hash
+    nullptr,                             // tp_call
+    nullptr,                             // tp_str
+    nullptr,                             // tp_getattro
+    nullptr,                             // tp_setattro
+    nullptr,                             // tp_as_buffer
+    Py_TPFLAGS_DEFAULT,                  // tp_flags
+    "A Enum Descriptor",                 // tp_doc
+    nullptr,                             // tp_traverse
+    nullptr,                             // tp_clear
+    nullptr,                             // tp_richcompare
+    0,                                   // tp_weaklistoffset
+    nullptr,                             // tp_iter
+    nullptr,                             // tp_iternext
+    enum_descriptor::Methods,            // tp_methods
+    nullptr,                             // tp_members
+    enum_descriptor::Getters,            // tp_getset
+    &descriptor::PyBaseDescriptor_Type,  // tp_base
+};
+
+PyObject* PyEnumDescriptor_FromDescriptor(
+    const EnumDescriptor* enum_descriptor) {
+  return descriptor::NewInternedDescriptor(&PyEnumDescriptor_Type,
+                                           enum_descriptor, nullptr);
+}
+
+const EnumDescriptor* PyEnumDescriptor_AsDescriptor(PyObject* obj) {
+  if (!PyObject_TypeCheck(obj, &PyEnumDescriptor_Type)) {
+    PyErr_SetString(PyExc_TypeError, "Not an EnumDescriptor");
+    return nullptr;
+  }
+  return reinterpret_cast<const EnumDescriptor*>(
+      reinterpret_cast<PyBaseDescriptor*>(obj)->descriptor);
+}
+
+namespace enumvalue_descriptor {
+
+// Unchecked accessor to the C++ pointer.
+static const EnumValueDescriptor* _GetDescriptor(
+    PyBaseDescriptor *self) {
+  return reinterpret_cast<const EnumValueDescriptor*>(self->descriptor);
+}
+
+static PyObject* GetName(PyBaseDescriptor *self, void *closure) {
+  return PyString_FromCppString(_GetDescriptor(self)->name());
+}
+
+static PyObject* GetNumber(PyBaseDescriptor *self, void *closure) {
+  return PyLong_FromLong(_GetDescriptor(self)->number());
+}
+
+static PyObject* GetIndex(PyBaseDescriptor *self, void *closure) {
+  return PyLong_FromLong(_GetDescriptor(self)->index());
+}
+
+static PyObject* GetType(PyBaseDescriptor *self, void *closure) {
+  return PyEnumDescriptor_FromDescriptor(_GetDescriptor(self)->type());
+}
+
+static PyObject* GetHasOptions(PyBaseDescriptor *self, void *closure) {
+  const EnumValueOptions& options(_GetDescriptor(self)->options());
+  if (&options != &EnumValueOptions::default_instance()) {
+    Py_RETURN_TRUE;
+  } else {
+    Py_RETURN_FALSE;
+  }
+}
+static int SetHasOptions(PyBaseDescriptor *self, PyObject *value,
+                         void *closure) {
+  return CheckCalledFromGeneratedFile("has_options");
+}
+
+static PyObject* GetOptions(PyBaseDescriptor *self) {
+  return GetOrBuildOptions(_GetDescriptor(self));
+}
+
+static int SetOptions(PyBaseDescriptor *self, PyObject *value,
+                      void *closure) {
+  return CheckCalledFromGeneratedFile("_options");
+}
+
+static int SetSerializedOptions(PyBaseDescriptor *self, PyObject *value,
+                                void *closure) {
+  return CheckCalledFromGeneratedFile("_serialized_options");
+}
+
+static PyGetSetDef Getters[] = {
+    {"name", (getter)GetName, nullptr, "name"},
+    {"number", (getter)GetNumber, nullptr, "number"},
+    {"index", (getter)GetIndex, nullptr, "index"},
+    {"type", (getter)GetType, nullptr, "index"},
+
+    {"has_options", (getter)GetHasOptions, (setter)SetHasOptions,
+     "Has Options"},
+    {"_options", (getter) nullptr, (setter)SetOptions, "Options"},
+    {"_serialized_options", (getter) nullptr, (setter)SetSerializedOptions,
+     "Serialized Options"},
+    {nullptr},
+};
+
+static PyMethodDef Methods[] = {
+    {"GetOptions", (PyCFunction)GetOptions, METH_NOARGS},
+    {nullptr},
+};
+
+}  // namespace enumvalue_descriptor
+
+PyTypeObject PyEnumValueDescriptor_Type = {
+    PyVarObject_HEAD_INIT(&PyType_Type, 0) FULL_MODULE_NAME
+    ".EnumValueDescriptor",    // tp_name
+    sizeof(PyBaseDescriptor),  // tp_basicsize
+    0,                         // tp_itemsize
+    nullptr,                   // tp_dealloc
+#if PY_VERSION_HEX < 0x03080000
+    nullptr,  // tp_print
+#else
+    0,  // tp_vectorcall_offset
+#endif
+    nullptr,                             // tp_getattr
+    nullptr,                             // tp_setattr
+    nullptr,                             // tp_compare
+    nullptr,                             // tp_repr
+    nullptr,                             // tp_as_number
+    nullptr,                             // tp_as_sequence
+    nullptr,                             // tp_as_mapping
+    nullptr,                             // tp_hash
+    nullptr,                             // tp_call
+    nullptr,                             // tp_str
+    nullptr,                             // tp_getattro
+    nullptr,                             // tp_setattro
+    nullptr,                             // tp_as_buffer
+    Py_TPFLAGS_DEFAULT,                  // tp_flags
+    "A EnumValue Descriptor",            // tp_doc
+    nullptr,                             // tp_traverse
+    nullptr,                             // tp_clear
+    nullptr,                             // tp_richcompare
+    0,                                   // tp_weaklistoffset
+    nullptr,                             // tp_iter
+    nullptr,                             // tp_iternext
+    enumvalue_descriptor::Methods,       // tp_methods
+    nullptr,                             // tp_members
+    enumvalue_descriptor::Getters,       // tp_getset
+    &descriptor::PyBaseDescriptor_Type,  // tp_base
+};
+
+PyObject* PyEnumValueDescriptor_FromDescriptor(
+    const EnumValueDescriptor* enumvalue_descriptor) {
+  return descriptor::NewInternedDescriptor(&PyEnumValueDescriptor_Type,
+                                           enumvalue_descriptor, nullptr);
+}
+
+namespace file_descriptor {
+
+// Unchecked accessor to the C++ pointer.
+static const FileDescriptor* _GetDescriptor(PyFileDescriptor *self) {
+  return reinterpret_cast<const FileDescriptor*>(self->base.descriptor);
+}
+
+static void Dealloc(PyFileDescriptor* self) {
+  Py_XDECREF(self->serialized_pb);
+  descriptor::Dealloc(reinterpret_cast<PyObject*>(self));
+}
+
+static PyObject* GetPool(PyFileDescriptor *self, void *closure) {
+  PyObject* pool = reinterpret_cast<PyObject*>(
+      GetDescriptorPool_FromPool(_GetDescriptor(self)->pool()));
+  Py_XINCREF(pool);
+  return pool;
+}
+
+static PyObject* GetName(PyFileDescriptor *self, void *closure) {
+  return PyString_FromCppString(_GetDescriptor(self)->name());
+}
+
+static PyObject* GetPackage(PyFileDescriptor *self, void *closure) {
+  return PyString_FromCppString(_GetDescriptor(self)->package());
+}
+
+static PyObject* GetSerializedPb(PyFileDescriptor *self, void *closure) {
+  PyObject *serialized_pb = self->serialized_pb;
+  if (serialized_pb != nullptr) {
+    Py_INCREF(serialized_pb);
+    return serialized_pb;
+  }
+  FileDescriptorProto file_proto;
+  _GetDescriptor(self)->CopyTo(&file_proto);
+  std::string contents;
+  file_proto.SerializePartialToString(&contents);
+  self->serialized_pb = PyBytes_FromStringAndSize(
+      contents.c_str(), contents.size());
+  if (self->serialized_pb == nullptr) {
+    return nullptr;
+  }
+  Py_INCREF(self->serialized_pb);
+  return self->serialized_pb;
+}
+
+static PyObject* GetMessageTypesByName(PyFileDescriptor* self, void *closure) {
+  return NewFileMessageTypesByName(_GetDescriptor(self));
+}
+
+static PyObject* GetEnumTypesByName(PyFileDescriptor* self, void *closure) {
+  return NewFileEnumTypesByName(_GetDescriptor(self));
+}
+
+static PyObject* GetExtensionsByName(PyFileDescriptor* self, void *closure) {
+  return NewFileExtensionsByName(_GetDescriptor(self));
+}
+
+static PyObject* GetServicesByName(PyFileDescriptor* self, void *closure) {
+  return NewFileServicesByName(_GetDescriptor(self));
+}
+
+static PyObject* GetDependencies(PyFileDescriptor* self, void *closure) {
+  return NewFileDependencies(_GetDescriptor(self));
+}
+
+static PyObject* GetPublicDependencies(PyFileDescriptor* self, void *closure) {
+  return NewFilePublicDependencies(_GetDescriptor(self));
+}
+
+static PyObject* GetHasOptions(PyFileDescriptor *self, void *closure) {
+  const FileOptions& options(_GetDescriptor(self)->options());
+  if (&options != &FileOptions::default_instance()) {
+    Py_RETURN_TRUE;
+  } else {
+    Py_RETURN_FALSE;
+  }
+}
+static int SetHasOptions(PyFileDescriptor *self, PyObject *value,
+                         void *closure) {
+  return CheckCalledFromGeneratedFile("has_options");
+}
+
+static PyObject* GetDebugString(PyFileDescriptor* self) {
+  return PyString_FromCppString(_GetDescriptor(self)->DebugString());
+}
+
+static PyObject* GetOptions(PyFileDescriptor *self) {
+  return GetOrBuildOptions(_GetDescriptor(self));
+}
+
+static int SetOptions(PyFileDescriptor *self, PyObject *value,
+                      void *closure) {
+  return CheckCalledFromGeneratedFile("_options");
+}
+
+static int SetSerializedOptions(PyFileDescriptor *self, PyObject *value,
+                                void *closure) {
+  return CheckCalledFromGeneratedFile("_serialized_options");
+}
+
+static PyObject* GetSyntax(PyFileDescriptor *self, void *closure) {
+  return PyUnicode_InternFromString(
+      FileDescriptor::SyntaxName(_GetDescriptor(self)->syntax()));
+}
+
+static PyObject* CopyToProto(PyFileDescriptor *self, PyObject *target) {
+  return CopyToPythonProto<FileDescriptorProto>(_GetDescriptor(self), target);
+}
+
+static PyGetSetDef Getters[] = {
+    {"pool", (getter)GetPool, nullptr, "pool"},
+    {"name", (getter)GetName, nullptr, "name"},
+    {"package", (getter)GetPackage, nullptr, "package"},
+    {"serialized_pb", (getter)GetSerializedPb},
+    {"message_types_by_name", (getter)GetMessageTypesByName, nullptr,
+     "Messages by name"},
+    {"enum_types_by_name", (getter)GetEnumTypesByName, nullptr,
+     "Enums by name"},
+    {"extensions_by_name", (getter)GetExtensionsByName, nullptr,
+     "Extensions by name"},
+    {"services_by_name", (getter)GetServicesByName, nullptr,
+     "Services by name"},
+    {"dependencies", (getter)GetDependencies, nullptr, "Dependencies"},
+    {"public_dependencies", (getter)GetPublicDependencies, nullptr,
+     "Dependencies"},
+
+    {"has_options", (getter)GetHasOptions, (setter)SetHasOptions,
+     "Has Options"},
+    {"_options", (getter) nullptr, (setter)SetOptions, "Options"},
+    {"_serialized_options", (getter) nullptr, (setter)SetSerializedOptions,
+     "Serialized Options"},
+    {"syntax", (getter)GetSyntax, (setter) nullptr, "Syntax"},
+    {nullptr},
+};
+
+static PyMethodDef Methods[] = {
+    {"GetDebugString", (PyCFunction)GetDebugString, METH_NOARGS},
+    {"GetOptions", (PyCFunction)GetOptions, METH_NOARGS},
+    {"CopyToProto", (PyCFunction)CopyToProto, METH_O},
+    {nullptr},
+};
+
+}  // namespace file_descriptor
+
+PyTypeObject PyFileDescriptor_Type = {
+    PyVarObject_HEAD_INIT(&PyType_Type, 0) FULL_MODULE_NAME
+    ".FileDescriptor",                     // tp_name
+    sizeof(PyFileDescriptor),              // tp_basicsize
+    0,                                     // tp_itemsize
+    (destructor)file_descriptor::Dealloc,  // tp_dealloc
+#if PY_VERSION_HEX < 0x03080000
+    nullptr,  // tp_print
+#else
+    0,  // tp_vectorcall_offset
+#endif
+    nullptr,                             // tp_getattr
+    nullptr,                             // tp_setattr
+    nullptr,                             // tp_compare
+    nullptr,                             // tp_repr
+    nullptr,                             // tp_as_number
+    nullptr,                             // tp_as_sequence
+    nullptr,                             // tp_as_mapping
+    nullptr,                             // tp_hash
+    nullptr,                             // tp_call
+    nullptr,                             // tp_str
+    nullptr,                             // tp_getattro
+    nullptr,                             // tp_setattro
+    nullptr,                             // tp_as_buffer
+    Py_TPFLAGS_DEFAULT,                  // tp_flags
+    "A File Descriptor",                 // tp_doc
+    nullptr,                             // tp_traverse
+    nullptr,                             // tp_clear
+    nullptr,                             // tp_richcompare
+    0,                                   // tp_weaklistoffset
+    nullptr,                             // tp_iter
+    nullptr,                             // tp_iternext
+    file_descriptor::Methods,            // tp_methods
+    nullptr,                             // tp_members
+    file_descriptor::Getters,            // tp_getset
+    &descriptor::PyBaseDescriptor_Type,  // tp_base
+    nullptr,                             // tp_dict
+    nullptr,                             // tp_descr_get
+    nullptr,                             // tp_descr_set
+    0,                                   // tp_dictoffset
+    nullptr,                             // tp_init
+    nullptr,                             // tp_alloc
+    nullptr,                             // tp_new
+    PyObject_GC_Del,                     // tp_free
+};
+
+PyObject* PyFileDescriptor_FromDescriptor(
+    const FileDescriptor* file_descriptor) {
+  return PyFileDescriptor_FromDescriptorWithSerializedPb(file_descriptor,
+                                                         nullptr);
+}
+
+PyObject* PyFileDescriptor_FromDescriptorWithSerializedPb(
+    const FileDescriptor* file_descriptor, PyObject *serialized_pb) {
+  bool was_created;
+  PyObject* py_descriptor = descriptor::NewInternedDescriptor(
+      &PyFileDescriptor_Type, file_descriptor, &was_created);
+  if (py_descriptor == nullptr) {
+    return nullptr;
+  }
+  if (was_created) {
+    PyFileDescriptor* cfile_descriptor =
+        reinterpret_cast<PyFileDescriptor*>(py_descriptor);
+    Py_XINCREF(serialized_pb);
+    cfile_descriptor->serialized_pb = serialized_pb;
+  }
+  // TODO(amauryfa): In the case of a cached object, check that serialized_pb
+  // is the same as before.
+
+  return py_descriptor;
+}
+
+const FileDescriptor* PyFileDescriptor_AsDescriptor(PyObject* obj) {
+  if (!PyObject_TypeCheck(obj, &PyFileDescriptor_Type)) {
+    PyErr_SetString(PyExc_TypeError, "Not a FileDescriptor");
+    return nullptr;
+  }
+  return reinterpret_cast<const FileDescriptor*>(
+      reinterpret_cast<PyBaseDescriptor*>(obj)->descriptor);
+}
+
+namespace oneof_descriptor {
+
+// Unchecked accessor to the C++ pointer.
+static const OneofDescriptor* _GetDescriptor(
+    PyBaseDescriptor *self) {
+  return reinterpret_cast<const OneofDescriptor*>(self->descriptor);
+}
+
+static PyObject* GetName(PyBaseDescriptor* self, void *closure) {
+  return PyString_FromCppString(_GetDescriptor(self)->name());
+}
+
+static PyObject* GetFullName(PyBaseDescriptor* self, void *closure) {
+  return PyString_FromCppString(_GetDescriptor(self)->full_name());
+}
+
+static PyObject* GetIndex(PyBaseDescriptor *self, void *closure) {
+  return PyLong_FromLong(_GetDescriptor(self)->index());
+}
+
+static PyObject* GetFields(PyBaseDescriptor* self, void *closure) {
+  return NewOneofFieldsSeq(_GetDescriptor(self));
+}
+
+static PyObject* GetContainingType(PyBaseDescriptor *self, void *closure) {
+  const Descriptor* containing_type =
+      _GetDescriptor(self)->containing_type();
+  if (containing_type) {
+    return PyMessageDescriptor_FromDescriptor(containing_type);
+  } else {
+    Py_RETURN_NONE;
+  }
+}
+
+static PyObject* GetHasOptions(PyBaseDescriptor *self, void *closure) {
+  const OneofOptions& options(_GetDescriptor(self)->options());
+  if (&options != &OneofOptions::default_instance()) {
+    Py_RETURN_TRUE;
+  } else {
+    Py_RETURN_FALSE;
+  }
+}
+
+static int SetHasOptions(PyBaseDescriptor *self, PyObject *value,
+                         void *closure) {
+  return CheckCalledFromGeneratedFile("has_options");
+}
+
+static PyObject* GetOptions(PyBaseDescriptor *self) {
+  return GetOrBuildOptions(_GetDescriptor(self));
+}
+
+static int SetOptions(PyBaseDescriptor *self, PyObject *value,
+                      void *closure) {
+  return CheckCalledFromGeneratedFile("_options");
+}
+
+static int SetSerializedOptions(PyBaseDescriptor *self, PyObject *value,
+                                void *closure) {
+  return CheckCalledFromGeneratedFile("_serialized_options");
+}
+
+static PyGetSetDef Getters[] = {
+    {"name", (getter)GetName, nullptr, "Name"},
+    {"full_name", (getter)GetFullName, nullptr, "Full name"},
+    {"index", (getter)GetIndex, nullptr, "Index"},
+
+    {"containing_type", (getter)GetContainingType, nullptr, "Containing type"},
+    {"has_options", (getter)GetHasOptions, (setter)SetHasOptions,
+     "Has Options"},
+    {"_options", (getter) nullptr, (setter)SetOptions, "Options"},
+    {"_serialized_options", (getter) nullptr, (setter)SetSerializedOptions,
+     "Serialized Options"},
+    {"fields", (getter)GetFields, nullptr, "Fields"},
+    {nullptr},
+};
+
+static PyMethodDef Methods[] = {
+    {"GetOptions", (PyCFunction)GetOptions, METH_NOARGS},
+    {nullptr},
+};
+
+}  // namespace oneof_descriptor
+
+PyTypeObject PyOneofDescriptor_Type = {
+    PyVarObject_HEAD_INIT(&PyType_Type, 0) FULL_MODULE_NAME
+    ".OneofDescriptor",        // tp_name
+    sizeof(PyBaseDescriptor),  // tp_basicsize
+    0,                         // tp_itemsize
+    nullptr,                   // tp_dealloc
+#if PY_VERSION_HEX < 0x03080000
+    nullptr,  // tp_print
+#else
+    0,  // tp_vectorcall_offset
+#endif
+    nullptr,                             // tp_getattr
+    nullptr,                             // tp_setattr
+    nullptr,                             // tp_compare
+    nullptr,                             // tp_repr
+    nullptr,                             // tp_as_number
+    nullptr,                             // tp_as_sequence
+    nullptr,                             // tp_as_mapping
+    nullptr,                             // tp_hash
+    nullptr,                             // tp_call
+    nullptr,                             // tp_str
+    nullptr,                             // tp_getattro
+    nullptr,                             // tp_setattro
+    nullptr,                             // tp_as_buffer
+    Py_TPFLAGS_DEFAULT,                  // tp_flags
+    "A Oneof Descriptor",                // tp_doc
+    nullptr,                             // tp_traverse
+    nullptr,                             // tp_clear
+    nullptr,                             // tp_richcompare
+    0,                                   // tp_weaklistoffset
+    nullptr,                             // tp_iter
+    nullptr,                             // tp_iternext
+    oneof_descriptor::Methods,           // tp_methods
+    nullptr,                             // tp_members
+    oneof_descriptor::Getters,           // tp_getset
+    &descriptor::PyBaseDescriptor_Type,  // tp_base
+};
+
+PyObject* PyOneofDescriptor_FromDescriptor(
+    const OneofDescriptor* oneof_descriptor) {
+  return descriptor::NewInternedDescriptor(&PyOneofDescriptor_Type,
+                                           oneof_descriptor, nullptr);
+}
+
+namespace service_descriptor {
+
+// Unchecked accessor to the C++ pointer.
+static const ServiceDescriptor* _GetDescriptor(
+    PyBaseDescriptor *self) {
+  return reinterpret_cast<const ServiceDescriptor*>(self->descriptor);
+}
+
+static PyObject* GetName(PyBaseDescriptor* self, void *closure) {
+  return PyString_FromCppString(_GetDescriptor(self)->name());
+}
+
+static PyObject* GetFullName(PyBaseDescriptor* self, void *closure) {
+  return PyString_FromCppString(_GetDescriptor(self)->full_name());
+}
+
+static PyObject* GetFile(PyBaseDescriptor *self, void *closure) {
+  return PyFileDescriptor_FromDescriptor(_GetDescriptor(self)->file());
+}
+
+static PyObject* GetIndex(PyBaseDescriptor *self, void *closure) {
+  return PyLong_FromLong(_GetDescriptor(self)->index());
+}
+
+static PyObject* GetMethods(PyBaseDescriptor* self, void *closure) {
+  return NewServiceMethodsSeq(_GetDescriptor(self));
+}
+
+static PyObject* GetMethodsByName(PyBaseDescriptor* self, void *closure) {
+  return NewServiceMethodsByName(_GetDescriptor(self));
+}
+
+static PyObject* FindMethodByName(PyBaseDescriptor *self, PyObject* arg) {
+  Py_ssize_t name_size;
+  char* name;
+  if (PyString_AsStringAndSize(arg, &name, &name_size) < 0) {
+    return nullptr;
+  }
+
+  const MethodDescriptor* method_descriptor =
+      _GetDescriptor(self)->FindMethodByName(StringParam(name, name_size));
+  if (method_descriptor == nullptr) {
+    PyErr_Format(PyExc_KeyError, "Couldn't find method %.200s", name);
+    return nullptr;
+  }
+
+  return PyMethodDescriptor_FromDescriptor(method_descriptor);
+}
+
+static PyObject* GetOptions(PyBaseDescriptor *self) {
+  return GetOrBuildOptions(_GetDescriptor(self));
+}
+
+static PyObject* CopyToProto(PyBaseDescriptor *self, PyObject *target) {
+  return CopyToPythonProto<ServiceDescriptorProto>(_GetDescriptor(self),
+                                                   target);
+}
+
+static PyGetSetDef Getters[] = {
+    {"name", (getter)GetName, nullptr, "Name", nullptr},
+    {"full_name", (getter)GetFullName, nullptr, "Full name", nullptr},
+    {"file", (getter)GetFile, nullptr, "File descriptor"},
+    {"index", (getter)GetIndex, nullptr, "Index", nullptr},
+    {"methods", (getter)GetMethods, nullptr, "Methods", nullptr},
+    {"methods_by_name", (getter)GetMethodsByName, nullptr, "Methods by name",
+     nullptr},
+    {nullptr},
+};
+
+static PyMethodDef Methods[] = {
+    {"GetOptions", (PyCFunction)GetOptions, METH_NOARGS},
+    {"CopyToProto", (PyCFunction)CopyToProto, METH_O},
+    {"FindMethodByName", (PyCFunction)FindMethodByName, METH_O},
+    {nullptr},
+};
+
+}  // namespace service_descriptor
+
+PyTypeObject PyServiceDescriptor_Type = {
+    PyVarObject_HEAD_INIT(&PyType_Type, 0) FULL_MODULE_NAME
+    ".ServiceDescriptor",      // tp_name
+    sizeof(PyBaseDescriptor),  // tp_basicsize
+    0,                         // tp_itemsize
+    nullptr,                   // tp_dealloc
+#if PY_VERSION_HEX < 0x03080000
+    nullptr,  // tp_print
+#else
+    0,  // tp_vectorcall_offset
+#endif
+    nullptr,                             // tp_getattr
+    nullptr,                             // tp_setattr
+    nullptr,                             // tp_compare
+    nullptr,                             // tp_repr
+    nullptr,                             // tp_as_number
+    nullptr,                             // tp_as_sequence
+    nullptr,                             // tp_as_mapping
+    nullptr,                             // tp_hash
+    nullptr,                             // tp_call
+    nullptr,                             // tp_str
+    nullptr,                             // tp_getattro
+    nullptr,                             // tp_setattro
+    nullptr,                             // tp_as_buffer
+    Py_TPFLAGS_DEFAULT,                  // tp_flags
+    "A Service Descriptor",              // tp_doc
+    nullptr,                             // tp_traverse
+    nullptr,                             // tp_clear
+    nullptr,                             // tp_richcompare
+    0,                                   // tp_weaklistoffset
+    nullptr,                             // tp_iter
+    nullptr,                             // tp_iternext
+    service_descriptor::Methods,         // tp_methods
+    nullptr,                             // tp_members
+    service_descriptor::Getters,         // tp_getset
+    &descriptor::PyBaseDescriptor_Type,  // tp_base
+};
+
+PyObject* PyServiceDescriptor_FromDescriptor(
+    const ServiceDescriptor* service_descriptor) {
+  return descriptor::NewInternedDescriptor(&PyServiceDescriptor_Type,
+                                           service_descriptor, nullptr);
+}
+
+const ServiceDescriptor* PyServiceDescriptor_AsDescriptor(PyObject* obj) {
+  if (!PyObject_TypeCheck(obj, &PyServiceDescriptor_Type)) {
+    PyErr_SetString(PyExc_TypeError, "Not a ServiceDescriptor");
+    return nullptr;
+  }
+  return reinterpret_cast<const ServiceDescriptor*>(
+      reinterpret_cast<PyBaseDescriptor*>(obj)->descriptor);
+}
+
+namespace method_descriptor {
+
+// Unchecked accessor to the C++ pointer.
+static const MethodDescriptor* _GetDescriptor(
+    PyBaseDescriptor *self) {
+  return reinterpret_cast<const MethodDescriptor*>(self->descriptor);
+}
+
+static PyObject* GetName(PyBaseDescriptor* self, void *closure) {
+  return PyString_FromCppString(_GetDescriptor(self)->name());
+}
+
+static PyObject* GetFullName(PyBaseDescriptor* self, void *closure) {
+  return PyString_FromCppString(_GetDescriptor(self)->full_name());
+}
+
+static PyObject* GetIndex(PyBaseDescriptor *self, void *closure) {
+  return PyLong_FromLong(_GetDescriptor(self)->index());
+}
+
+static PyObject* GetContainingService(PyBaseDescriptor *self, void *closure) {
+  const ServiceDescriptor* containing_service =
+      _GetDescriptor(self)->service();
+  return PyServiceDescriptor_FromDescriptor(containing_service);
+}
+
+static PyObject* GetInputType(PyBaseDescriptor *self, void *closure) {
+  const Descriptor* input_type = _GetDescriptor(self)->input_type();
+  return PyMessageDescriptor_FromDescriptor(input_type);
+}
+
+static PyObject* GetOutputType(PyBaseDescriptor *self, void *closure) {
+  const Descriptor* output_type = _GetDescriptor(self)->output_type();
+  return PyMessageDescriptor_FromDescriptor(output_type);
+}
+
+static PyObject* GetClientStreaming(PyBaseDescriptor* self, void* closure) {
+  return PyBool_FromLong(_GetDescriptor(self)->client_streaming() ? 1 : 0);
+}
+
+static PyObject* GetServerStreaming(PyBaseDescriptor* self, void* closure) {
+  return PyBool_FromLong(_GetDescriptor(self)->server_streaming() ? 1 : 0);
+}
+
+static PyObject* GetOptions(PyBaseDescriptor *self) {
+  return GetOrBuildOptions(_GetDescriptor(self));
+}
+
+static PyObject* CopyToProto(PyBaseDescriptor *self, PyObject *target) {
+  return CopyToPythonProto<MethodDescriptorProto>(_GetDescriptor(self), target);
+}
+
+static PyGetSetDef Getters[] = {
+    {"name", (getter)GetName, nullptr, "Name", nullptr},
+    {"full_name", (getter)GetFullName, nullptr, "Full name", nullptr},
+    {"index", (getter)GetIndex, nullptr, "Index", nullptr},
+    {"containing_service", (getter)GetContainingService, nullptr,
+     "Containing service", nullptr},
+    {"input_type", (getter)GetInputType, nullptr, "Input type", nullptr},
+    {"output_type", (getter)GetOutputType, nullptr, "Output type", nullptr},
+    {"client_streaming", (getter)GetClientStreaming, nullptr,
+     "Client streaming", nullptr},
+    {"server_streaming", (getter)GetServerStreaming, nullptr,
+     "Server streaming", nullptr},
+    {nullptr},
+};
+
+static PyMethodDef Methods[] = {
+    {"GetOptions", (PyCFunction)GetOptions, METH_NOARGS},
+    {"CopyToProto", (PyCFunction)CopyToProto, METH_O},
+    {nullptr},
+};
+
+}  // namespace method_descriptor
+
+PyTypeObject PyMethodDescriptor_Type = {
+    PyVarObject_HEAD_INIT(&PyType_Type, 0) FULL_MODULE_NAME
+    ".MethodDescriptor",       // tp_name
+    sizeof(PyBaseDescriptor),  // tp_basicsize
+    0,                         // tp_itemsize
+    nullptr,                   // tp_dealloc
+#if PY_VERSION_HEX < 0x03080000
+    nullptr,  // tp_print
+#else
+    0,  // tp_vectorcall_offset
+#endif
+    nullptr,                             // tp_getattr
+    nullptr,                             // tp_setattr
+    nullptr,                             // tp_compare
+    nullptr,                             // tp_repr
+    nullptr,                             // tp_as_number
+    nullptr,                             // tp_as_sequence
+    nullptr,                             // tp_as_mapping
+    nullptr,                             // tp_hash
+    nullptr,                             // tp_call
+    nullptr,                             // tp_str
+    nullptr,                             // tp_getattro
+    nullptr,                             // tp_setattro
+    nullptr,                             // tp_as_buffer
+    Py_TPFLAGS_DEFAULT,                  // tp_flags
+    "A Method Descriptor",               // tp_doc
+    nullptr,                             // tp_traverse
+    nullptr,                             // tp_clear
+    nullptr,                             // tp_richcompare
+    0,                                   // tp_weaklistoffset
+    nullptr,                             // tp_iter
+    nullptr,                             // tp_iternext
+    method_descriptor::Methods,          // tp_methods
+    nullptr,                             // tp_members
+    method_descriptor::Getters,          // tp_getset
+    &descriptor::PyBaseDescriptor_Type,  // tp_base
+};
+
+PyObject* PyMethodDescriptor_FromDescriptor(
+    const MethodDescriptor* method_descriptor) {
+  return descriptor::NewInternedDescriptor(&PyMethodDescriptor_Type,
+                                           method_descriptor, nullptr);
+}
+
+// Add a enum values to a type dictionary.
+static bool AddEnumValues(PyTypeObject *type,
+                          const EnumDescriptor* enum_descriptor) {
+  for (int i = 0; i < enum_descriptor->value_count(); ++i) {
+    const EnumValueDescriptor* value = enum_descriptor->value(i);
+    ScopedPyObjectPtr obj(PyLong_FromLong(value->number()));
+    if (obj == nullptr) {
+      return false;
+    }
+    if (PyDict_SetItemString(type->tp_dict, value->name().c_str(), obj.get()) <
+        0) {
+      return false;
+    }
+  }
+  return true;
+}
+
+static bool AddIntConstant(PyTypeObject *type, const char* name, int value) {
+  ScopedPyObjectPtr obj(PyLong_FromLong(value));
+  if (PyDict_SetItemString(type->tp_dict, name, obj.get()) < 0) {
+    return false;
+  }
+  return true;
+}
+
+
+bool InitDescriptor() {
+  if (PyType_Ready(&PyMessageDescriptor_Type) < 0)
+    return false;
+
+  if (PyType_Ready(&PyFieldDescriptor_Type) < 0)
+    return false;
+
+  if (!AddEnumValues(&PyFieldDescriptor_Type,
+                     FieldDescriptorProto::Label_descriptor())) {
+    return false;
+  }
+  if (!AddEnumValues(&PyFieldDescriptor_Type,
+                     FieldDescriptorProto::Type_descriptor())) {
+    return false;
+  }
+#define ADD_FIELDDESC_CONSTANT(NAME) AddIntConstant( \
+    &PyFieldDescriptor_Type, #NAME, FieldDescriptor::NAME)
+  if (!ADD_FIELDDESC_CONSTANT(CPPTYPE_INT32) ||
+      !ADD_FIELDDESC_CONSTANT(CPPTYPE_INT64) ||
+      !ADD_FIELDDESC_CONSTANT(CPPTYPE_UINT32) ||
+      !ADD_FIELDDESC_CONSTANT(CPPTYPE_UINT64) ||
+      !ADD_FIELDDESC_CONSTANT(CPPTYPE_DOUBLE) ||
+      !ADD_FIELDDESC_CONSTANT(CPPTYPE_FLOAT) ||
+      !ADD_FIELDDESC_CONSTANT(CPPTYPE_BOOL) ||
+      !ADD_FIELDDESC_CONSTANT(CPPTYPE_ENUM) ||
+      !ADD_FIELDDESC_CONSTANT(CPPTYPE_STRING) ||
+      !ADD_FIELDDESC_CONSTANT(CPPTYPE_MESSAGE)) {
+    return false;
+  }
+#undef ADD_FIELDDESC_CONSTANT
+
+  if (PyType_Ready(&PyEnumDescriptor_Type) < 0)
+    return false;
+
+  if (PyType_Ready(&PyEnumValueDescriptor_Type) < 0)
+    return false;
+
+  if (PyType_Ready(&PyFileDescriptor_Type) < 0)
+    return false;
+
+  if (PyType_Ready(&PyOneofDescriptor_Type) < 0)
+    return false;
+
+  if (PyType_Ready(&PyServiceDescriptor_Type) < 0)
+    return false;
+
+  if (PyType_Ready(&PyMethodDescriptor_Type) < 0)
+    return false;
+
+  if (!InitDescriptorMappingTypes())
+    return false;
+
+  // Initialize globals defined in this file.
+  interned_descriptors = new std::unordered_map<const void*, PyObject*>;
+
+  return true;
+}
+
+}  // namespace python
+}  // namespace protobuf
+}  // namespace google
diff --git a/lark_channel/ws/pb/google/protobuf/pyext/descriptor.h b/lark_channel/ws/pb/google/protobuf/pyext/descriptor.h
new file mode 100644
index 0000000..d97e2f8
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/pyext/descriptor.h
@@ -0,0 +1,108 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: petar@google.com (Petar Petrov)
+
+#ifndef GOOGLE_PROTOBUF_PYTHON_CPP_DESCRIPTOR_H__
+#define GOOGLE_PROTOBUF_PYTHON_CPP_DESCRIPTOR_H__
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+#include <google/protobuf/descriptor.h>
+
+namespace google {
+namespace protobuf {
+namespace python {
+
+// Should match the type of ConstStringParam.
+using StringParam = std::string;
+
+extern PyTypeObject PyMessageDescriptor_Type;
+extern PyTypeObject PyFieldDescriptor_Type;
+extern PyTypeObject PyEnumDescriptor_Type;
+extern PyTypeObject PyEnumValueDescriptor_Type;
+extern PyTypeObject PyFileDescriptor_Type;
+extern PyTypeObject PyOneofDescriptor_Type;
+extern PyTypeObject PyServiceDescriptor_Type;
+extern PyTypeObject PyMethodDescriptor_Type;
+
+// Wraps a Descriptor in a Python object.
+// The C++ pointer is usually borrowed from the global DescriptorPool.
+// In any case, it must stay alive as long as the Python object.
+// Returns a new reference.
+PyObject* PyMessageDescriptor_FromDescriptor(const Descriptor* descriptor);
+PyObject* PyFieldDescriptor_FromDescriptor(const FieldDescriptor* descriptor);
+PyObject* PyEnumDescriptor_FromDescriptor(const EnumDescriptor* descriptor);
+PyObject* PyEnumValueDescriptor_FromDescriptor(
+    const EnumValueDescriptor* descriptor);
+PyObject* PyOneofDescriptor_FromDescriptor(const OneofDescriptor* descriptor);
+PyObject* PyFileDescriptor_FromDescriptor(
+    const FileDescriptor* file_descriptor);
+PyObject* PyServiceDescriptor_FromDescriptor(
+    const ServiceDescriptor* descriptor);
+PyObject* PyMethodDescriptor_FromDescriptor(
+    const MethodDescriptor* descriptor);
+
+// Alternate constructor of PyFileDescriptor, used when we already have a
+// serialized FileDescriptorProto that can be cached.
+// Returns a new reference.
+PyObject* PyFileDescriptor_FromDescriptorWithSerializedPb(
+    const FileDescriptor* file_descriptor, PyObject* serialized_pb);
+
+// Return the C++ descriptor pointer.
+// This function checks the parameter type; on error, return NULL with a Python
+// exception set.
+const Descriptor* PyMessageDescriptor_AsDescriptor(PyObject* obj);
+const FieldDescriptor* PyFieldDescriptor_AsDescriptor(PyObject* obj);
+const EnumDescriptor* PyEnumDescriptor_AsDescriptor(PyObject* obj);
+const FileDescriptor* PyFileDescriptor_AsDescriptor(PyObject* obj);
+const ServiceDescriptor* PyServiceDescriptor_AsDescriptor(PyObject* obj);
+
+// Returns the raw C++ pointer.
+const void* PyDescriptor_AsVoidPtr(PyObject* obj);
+
+// Check that the calling Python code is the global scope of a _pb2.py module.
+// This function is used to support the current code generated by the proto
+// compiler, which insists on modifying descriptors after they have been
+// created.
+//
+// stacklevel indicates which Python frame should be the _pb2.py module.
+//
+// Don't use this function outside descriptor classes.
+bool _CalledFromGeneratedFile(int stacklevel);
+
+bool InitDescriptor();
+
+}  // namespace python
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_PYTHON_CPP_DESCRIPTOR_H__
diff --git a/lark_channel/ws/pb/google/protobuf/pyext/descriptor_containers.cc b/lark_channel/ws/pb/google/protobuf/pyext/descriptor_containers.cc
new file mode 100644
index 0000000..a87155b
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/pyext/descriptor_containers.cc
@@ -0,0 +1,1689 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Mappings and Sequences of descriptors.
+// Used by Descriptor.fields_by_name, EnumDescriptor.values...
+//
+// They avoid the allocation of a full dictionary or a full list: they simply
+// store a pointer to the parent descriptor, use the C++ Descriptor methods (see
+// net/proto2/public/descriptor.h) to retrieve other descriptors, and create
+// Python objects on the fly.
+//
+// The containers fully conform to abc.Mapping and abc.Sequence, and behave just
+// like read-only dictionaries and lists.
+//
+// Because the interface of C++ Descriptors is quite regular, this file actually
+// defines only three types, the exact behavior of a container is controlled by
+// a DescriptorContainerDef structure, which contains functions that uses the
+// public Descriptor API.
+//
+// Note: This DescriptorContainerDef is similar to the "virtual methods table"
+// that a C++ compiler generates for a class. We have to make it explicit
+// because the Python API is based on C, and does not play well with C++
+// inheritance.
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/pyext/descriptor_containers.h>
+#include <google/protobuf/pyext/descriptor_pool.h>
+#include <google/protobuf/pyext/descriptor.h>
+#include <google/protobuf/pyext/scoped_pyobject_ptr.h>
+
+#define PyString_AsStringAndSize(ob, charpp, sizep)              \
+  (PyUnicode_Check(ob)                                           \
+       ? ((*(charpp) = const_cast<char*>(                        \
+               PyUnicode_AsUTF8AndSize(ob, (sizep)))) == nullptr \
+              ? -1                                               \
+              : 0)                                               \
+       : PyBytes_AsStringAndSize(ob, (charpp), (sizep)))
+
+namespace google {
+namespace protobuf {
+namespace python {
+
+struct PyContainer;
+
+typedef int (*CountMethod)(PyContainer* self);
+typedef const void* (*GetByIndexMethod)(PyContainer* self, int index);
+typedef const void* (*GetByNameMethod)(PyContainer* self,
+                                       ConstStringParam name);
+typedef const void* (*GetByCamelcaseNameMethod)(PyContainer* self,
+                                                ConstStringParam name);
+typedef const void* (*GetByNumberMethod)(PyContainer* self, int index);
+typedef PyObject* (*NewObjectFromItemMethod)(const void* descriptor);
+typedef const std::string& (*GetItemNameMethod)(const void* descriptor);
+typedef const std::string& (*GetItemCamelcaseNameMethod)(
+    const void* descriptor);
+typedef int (*GetItemNumberMethod)(const void* descriptor);
+typedef int (*GetItemIndexMethod)(const void* descriptor);
+
+struct DescriptorContainerDef {
+  const char* mapping_name;
+  // Returns the number of items in the container.
+  CountMethod count_fn;
+  // Retrieve item by index (usually the order of declaration in the proto file)
+  // Used by sequences, but also iterators. 0 <= index < Count().
+  GetByIndexMethod get_by_index_fn;
+  // Retrieve item by name (usually a call to some 'FindByName' method).
+  // Used by "by_name" mappings.
+  GetByNameMethod get_by_name_fn;
+  // Retrieve item by camelcase name (usually a call to some
+  // 'FindByCamelcaseName' method). Used by "by_camelcase_name" mappings.
+  GetByCamelcaseNameMethod get_by_camelcase_name_fn;
+  // Retrieve item by declared number (field tag, or enum value).
+  // Used by "by_number" mappings.
+  GetByNumberMethod get_by_number_fn;
+  // Converts a item C++ descriptor to a Python object. Returns a new reference.
+  NewObjectFromItemMethod new_object_from_item_fn;
+  // Retrieve the name of an item. Used by iterators on "by_name" mappings.
+  GetItemNameMethod get_item_name_fn;
+  // Retrieve the camelcase name of an item. Used by iterators on
+  // "by_camelcase_name" mappings.
+  GetItemCamelcaseNameMethod get_item_camelcase_name_fn;
+  // Retrieve the number of an item. Used by iterators on "by_number" mappings.
+  GetItemNumberMethod get_item_number_fn;
+  // Retrieve the index of an item for the container type.
+  // Used by "__contains__".
+  // If not set, "x in sequence" will do a linear search.
+  GetItemIndexMethod get_item_index_fn;
+};
+
+struct PyContainer {
+  PyObject_HEAD
+
+  // The proto2 descriptor this container belongs to the global DescriptorPool.
+  const void* descriptor;
+
+  // A pointer to a static structure with function pointers that control the
+  // behavior of the container. Very similar to the table of virtual functions
+  // of a C++ class.
+  const DescriptorContainerDef* container_def;
+
+  // The kind of container: list, or dict by name or value.
+  enum ContainerKind {
+    KIND_SEQUENCE,
+    KIND_BYNAME,
+    KIND_BYCAMELCASENAME,
+    KIND_BYNUMBER,
+  } kind;
+};
+
+struct PyContainerIterator {
+  PyObject_HEAD
+
+  // The container we are iterating over. Own a reference.
+  PyContainer* container;
+
+  // The current index in the iterator.
+  int index;
+
+  // The kind of container: list, or dict by name or value.
+  enum IterKind {
+    KIND_ITERKEY,
+    KIND_ITERVALUE,
+    KIND_ITERITEM,
+    KIND_ITERVALUE_REVERSED,  // For sequences
+  } kind;
+};
+
+namespace descriptor {
+
+// Returns the C++ item descriptor for a given Python key.
+// When the descriptor is found, return true and set *item.
+// When the descriptor is not found, return true, but set *item to null.
+// On error, returns false with an exception set.
+static bool _GetItemByKey(PyContainer* self, PyObject* key, const void** item) {
+  switch (self->kind) {
+    case PyContainer::KIND_BYNAME: {
+      char* name;
+      Py_ssize_t name_size;
+      if (PyString_AsStringAndSize(key, &name, &name_size) < 0) {
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+          // Not a string, cannot be in the container.
+          PyErr_Clear();
+          *item = nullptr;
+          return true;
+        }
+        return false;
+      }
+      *item = self->container_def->get_by_name_fn(self,
+                                                  StringParam(name, name_size));
+      return true;
+    }
+    case PyContainer::KIND_BYCAMELCASENAME: {
+      char* camelcase_name;
+      Py_ssize_t name_size;
+      if (PyString_AsStringAndSize(key, &camelcase_name, &name_size) < 0) {
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+          // Not a string, cannot be in the container.
+          PyErr_Clear();
+          *item = nullptr;
+          return true;
+        }
+        return false;
+      }
+      *item = self->container_def->get_by_camelcase_name_fn(
+          self, StringParam(camelcase_name, name_size));
+      return true;
+    }
+    case PyContainer::KIND_BYNUMBER: {
+      Py_ssize_t number = PyNumber_AsSsize_t(key, nullptr);
+      if (number == -1 && PyErr_Occurred()) {
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+          // Not a number, cannot be in the container.
+          PyErr_Clear();
+          *item = nullptr;
+          return true;
+        }
+        return false;
+      }
+      *item = self->container_def->get_by_number_fn(self, number);
+      return true;
+    }
+    default:
+      PyErr_SetNone(PyExc_NotImplementedError);
+      return false;
+  }
+}
+
+// Returns the key of the object at the given index.
+// Used when iterating over mappings.
+static PyObject* _NewKey_ByIndex(PyContainer* self, Py_ssize_t index) {
+  const void* item = self->container_def->get_by_index_fn(self, index);
+  switch (self->kind) {
+    case PyContainer::KIND_BYNAME: {
+      const std::string& name(self->container_def->get_item_name_fn(item));
+      return PyUnicode_FromStringAndSize(name.c_str(), name.size());
+    }
+    case PyContainer::KIND_BYCAMELCASENAME: {
+      const std::string& name(
+          self->container_def->get_item_camelcase_name_fn(item));
+      return PyUnicode_FromStringAndSize(name.c_str(), name.size());
+    }
+    case PyContainer::KIND_BYNUMBER: {
+      int value = self->container_def->get_item_number_fn(item);
+      return PyLong_FromLong(value);
+    }
+    default:
+      PyErr_SetNone(PyExc_NotImplementedError);
+      return nullptr;
+  }
+}
+
+// Returns the object at the given index.
+// Also used when iterating over mappings.
+static PyObject* _NewObj_ByIndex(PyContainer* self, Py_ssize_t index) {
+  return self->container_def->new_object_from_item_fn(
+      self->container_def->get_by_index_fn(self, index));
+}
+
+static Py_ssize_t Length(PyContainer* self) {
+  return self->container_def->count_fn(self);
+}
+
+// The DescriptorMapping type.
+
+static PyObject* Subscript(PyContainer* self, PyObject* key) {
+  const void* item = nullptr;
+  if (!_GetItemByKey(self, key, &item)) {
+    return nullptr;
+  }
+  if (!item) {
+    PyErr_SetObject(PyExc_KeyError, key);
+    return nullptr;
+  }
+  return self->container_def->new_object_from_item_fn(item);
+}
+
+static int AssSubscript(PyContainer* self, PyObject* key, PyObject* value) {
+  if (_CalledFromGeneratedFile(0)) {
+    return 0;
+  }
+  PyErr_Format(PyExc_TypeError,
+               "'%.200s' object does not support item assignment",
+               Py_TYPE(self)->tp_name);
+  return -1;
+}
+
+static PyMappingMethods MappingMappingMethods = {
+  (lenfunc)Length,               // mp_length
+  (binaryfunc)Subscript,         // mp_subscript
+  (objobjargproc)AssSubscript,   // mp_ass_subscript
+};
+
+static int Contains(PyContainer* self, PyObject* key) {
+  const void* item = nullptr;
+  if (!_GetItemByKey(self, key, &item)) {
+    return -1;
+  }
+  if (item) {
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+static PyObject* ContainerRepr(PyContainer* self) {
+  const char* kind = "";
+  switch (self->kind) {
+    case PyContainer::KIND_SEQUENCE:
+      kind = "sequence";
+      break;
+    case PyContainer::KIND_BYNAME:
+      kind = "mapping by name";
+      break;
+    case PyContainer::KIND_BYCAMELCASENAME:
+      kind = "mapping by camelCase name";
+      break;
+    case PyContainer::KIND_BYNUMBER:
+      kind = "mapping by number";
+      break;
+  }
+  return PyUnicode_FromFormat("<%s %s>", self->container_def->mapping_name,
+                              kind);
+}
+
+extern PyTypeObject DescriptorMapping_Type;
+extern PyTypeObject DescriptorSequence_Type;
+
+// A sequence container can only be equal to another sequence container, or (for
+// backward compatibility) to a list containing the same items.
+// Returns 1 if equal, 0 if unequal, -1 on error.
+static int DescriptorSequence_Equal(PyContainer* self, PyObject* other) {
+  // Check the identity of C++ pointers.
+  if (PyObject_TypeCheck(other, &DescriptorSequence_Type)) {
+    PyContainer* other_container = reinterpret_cast<PyContainer*>(other);
+    if (self->descriptor == other_container->descriptor &&
+        self->container_def == other_container->container_def &&
+        self->kind == other_container->kind) {
+      return 1;
+    } else {
+      return 0;
+    }
+  }
+
+  // If other is a list
+  if (PyList_Check(other)) {
+    // return list(self) == other
+    int size = Length(self);
+    if (size != PyList_Size(other)) {
+      return false;
+    }
+    for (int index = 0; index < size; index++) {
+      ScopedPyObjectPtr value1(_NewObj_ByIndex(self, index));
+      if (value1 == nullptr) {
+        return -1;
+      }
+      PyObject* value2 = PyList_GetItem(other, index);
+      if (value2 == nullptr) {
+        return -1;
+      }
+      int cmp = PyObject_RichCompareBool(value1.get(), value2, Py_EQ);
+      if (cmp != 1)  // error or not equal
+          return cmp;
+    }
+    // All items were found and equal
+    return 1;
+  }
+
+  // Any other object is different.
+  return 0;
+}
+
+// A mapping container can only be equal to another mapping container, or (for
+// backward compatibility) to a dict containing the same items.
+// Returns 1 if equal, 0 if unequal, -1 on error.
+static int DescriptorMapping_Equal(PyContainer* self, PyObject* other) {
+  // Check the identity of C++ pointers.
+  if (PyObject_TypeCheck(other, &DescriptorMapping_Type)) {
+    PyContainer* other_container = reinterpret_cast<PyContainer*>(other);
+    if (self->descriptor == other_container->descriptor &&
+        self->container_def == other_container->container_def &&
+        self->kind == other_container->kind) {
+      return 1;
+    } else {
+      return 0;
+    }
+  }
+
+  // If other is a dict
+  if (PyDict_Check(other)) {
+    // equivalent to dict(self.items()) == other
+    int size = Length(self);
+    if (size != PyDict_Size(other)) {
+      return false;
+    }
+    for (int index = 0; index < size; index++) {
+      ScopedPyObjectPtr key(_NewKey_ByIndex(self, index));
+      if (key == nullptr) {
+        return -1;
+      }
+      ScopedPyObjectPtr value1(_NewObj_ByIndex(self, index));
+      if (value1 == nullptr) {
+        return -1;
+      }
+      PyObject* value2 = PyDict_GetItem(other, key.get());
+      if (value2 == nullptr) {
+        // Not found in the other dictionary
+        return 0;
+      }
+      int cmp = PyObject_RichCompareBool(value1.get(), value2, Py_EQ);
+      if (cmp != 1)  // error or not equal
+          return cmp;
+    }
+    // All items were found and equal
+    return 1;
+  }
+
+  // Any other object is different.
+  return 0;
+}
+
+static PyObject* RichCompare(PyContainer* self, PyObject* other, int opid) {
+  if (opid != Py_EQ && opid != Py_NE) {
+    Py_INCREF(Py_NotImplemented);
+    return Py_NotImplemented;
+  }
+
+  int result;
+
+  if (self->kind == PyContainer::KIND_SEQUENCE) {
+    result = DescriptorSequence_Equal(self, other);
+  } else {
+    result = DescriptorMapping_Equal(self, other);
+  }
+  if (result < 0) {
+    return nullptr;
+  }
+  if (result ^ (opid == Py_NE)) {
+    Py_RETURN_TRUE;
+  } else {
+    Py_RETURN_FALSE;
+  }
+}
+
+static PySequenceMethods MappingSequenceMethods = {
+    nullptr,               // sq_length
+    nullptr,               // sq_concat
+    nullptr,               // sq_repeat
+    nullptr,               // sq_item
+    nullptr,               // sq_slice
+    nullptr,               // sq_ass_item
+    nullptr,               // sq_ass_slice
+    (objobjproc)Contains,  // sq_contains
+};
+
+static PyObject* Get(PyContainer* self, PyObject* args) {
+  PyObject* key;
+  PyObject* default_value = Py_None;
+  if (!PyArg_UnpackTuple(args, "get", 1, 2, &key, &default_value)) {
+    return nullptr;
+  }
+
+  const void* item;
+  if (!_GetItemByKey(self, key, &item)) {
+    return nullptr;
+  }
+  if (item == nullptr) {
+    Py_INCREF(default_value);
+    return default_value;
+  }
+  return self->container_def->new_object_from_item_fn(item);
+}
+
+static PyObject* Keys(PyContainer* self, PyObject* args) {
+  Py_ssize_t count = Length(self);
+  ScopedPyObjectPtr list(PyList_New(count));
+  if (list == nullptr) {
+    return nullptr;
+  }
+  for (Py_ssize_t index = 0; index < count; ++index) {
+    PyObject* key = _NewKey_ByIndex(self, index);
+    if (key == nullptr) {
+      return nullptr;
+    }
+    PyList_SET_ITEM(list.get(), index, key);
+  }
+  return list.release();
+}
+
+static PyObject* Values(PyContainer* self, PyObject* args) {
+  Py_ssize_t count = Length(self);
+  ScopedPyObjectPtr list(PyList_New(count));
+  if (list == nullptr) {
+    return nullptr;
+  }
+  for (Py_ssize_t index = 0; index < count; ++index) {
+    PyObject* value = _NewObj_ByIndex(self, index);
+    if (value == nullptr) {
+      return nullptr;
+    }
+    PyList_SET_ITEM(list.get(), index, value);
+  }
+  return list.release();
+}
+
+static PyObject* Items(PyContainer* self, PyObject* args) {
+  Py_ssize_t count = Length(self);
+  ScopedPyObjectPtr list(PyList_New(count));
+  if (list == nullptr) {
+    return nullptr;
+  }
+  for (Py_ssize_t index = 0; index < count; ++index) {
+    ScopedPyObjectPtr obj(PyTuple_New(2));
+    if (obj == nullptr) {
+      return nullptr;
+    }
+    PyObject* key = _NewKey_ByIndex(self, index);
+    if (key == nullptr) {
+      return nullptr;
+    }
+    PyTuple_SET_ITEM(obj.get(), 0, key);
+    PyObject* value = _NewObj_ByIndex(self, index);
+    if (value == nullptr) {
+      return nullptr;
+    }
+    PyTuple_SET_ITEM(obj.get(), 1, value);
+    PyList_SET_ITEM(list.get(), index, obj.release());
+  }
+  return list.release();
+}
+
+static PyObject* NewContainerIterator(PyContainer* mapping,
+                                      PyContainerIterator::IterKind kind);
+
+static PyObject* Iter(PyContainer* self) {
+  return NewContainerIterator(self, PyContainerIterator::KIND_ITERKEY);
+}
+static PyObject* IterKeys(PyContainer* self, PyObject* args) {
+  return NewContainerIterator(self, PyContainerIterator::KIND_ITERKEY);
+}
+static PyObject* IterValues(PyContainer* self, PyObject* args) {
+  return NewContainerIterator(self, PyContainerIterator::KIND_ITERVALUE);
+}
+static PyObject* IterItems(PyContainer* self, PyObject* args) {
+  return NewContainerIterator(self, PyContainerIterator::KIND_ITERITEM);
+}
+
+static PyMethodDef MappingMethods[] = {
+    {"get", (PyCFunction)Get, METH_VARARGS},
+    {"keys", (PyCFunction)Keys, METH_NOARGS},
+    {"values", (PyCFunction)Values, METH_NOARGS},
+    {"items", (PyCFunction)Items, METH_NOARGS},
+    {"iterkeys", (PyCFunction)IterKeys, METH_NOARGS},
+    {"itervalues", (PyCFunction)IterValues, METH_NOARGS},
+    {"iteritems", (PyCFunction)IterItems, METH_NOARGS},
+    {nullptr},
+};
+
+PyTypeObject DescriptorMapping_Type = {
+    PyVarObject_HEAD_INIT(&PyType_Type, 0) "DescriptorMapping",  // tp_name
+    sizeof(PyContainer),                                         // tp_basicsize
+    0,                                                           // tp_itemsize
+    nullptr,                                                     // tp_dealloc
+#if PY_VERSION_HEX < 0x03080000
+    nullptr,  // tp_print
+#else
+    0,  // tp_vectorcall_offset
+#endif
+    nullptr,                   // tp_getattr
+    nullptr,                   // tp_setattr
+    nullptr,                   // tp_compare
+    (reprfunc)ContainerRepr,   // tp_repr
+    nullptr,                   // tp_as_number
+    &MappingSequenceMethods,   // tp_as_sequence
+    &MappingMappingMethods,    // tp_as_mapping
+    nullptr,                   // tp_hash
+    nullptr,                   // tp_call
+    nullptr,                   // tp_str
+    nullptr,                   // tp_getattro
+    nullptr,                   // tp_setattro
+    nullptr,                   // tp_as_buffer
+    Py_TPFLAGS_DEFAULT,        // tp_flags
+    nullptr,                   // tp_doc
+    nullptr,                   // tp_traverse
+    nullptr,                   // tp_clear
+    (richcmpfunc)RichCompare,  // tp_richcompare
+    0,                         // tp_weaklistoffset
+    (getiterfunc)Iter,         // tp_iter
+    nullptr,                   // tp_iternext
+    MappingMethods,            // tp_methods
+    nullptr,                   // tp_members
+    nullptr,                   // tp_getset
+    nullptr,                   // tp_base
+    nullptr,                   // tp_dict
+    nullptr,                   // tp_descr_get
+    nullptr,                   // tp_descr_set
+    0,                         // tp_dictoffset
+    nullptr,                   // tp_init
+    nullptr,                   // tp_alloc
+    nullptr,                   // tp_new
+    nullptr,                   // tp_free
+};
+
+// The DescriptorSequence type.
+
+static PyObject* GetItem(PyContainer* self, Py_ssize_t index) {
+  if (index < 0) {
+    index += Length(self);
+  }
+  if (index < 0 || index >= Length(self)) {
+    PyErr_SetString(PyExc_IndexError, "index out of range");
+    return nullptr;
+  }
+  return _NewObj_ByIndex(self, index);
+}
+
+static PyObject *
+SeqSubscript(PyContainer* self, PyObject* item) {
+  if (PyIndex_Check(item)) {
+      Py_ssize_t index;
+      index = PyNumber_AsSsize_t(item, PyExc_IndexError);
+      if (index == -1 && PyErr_Occurred()) return nullptr;
+      return GetItem(self, index);
+  }
+  // Materialize the list and delegate the operation to it.
+  ScopedPyObjectPtr list(PyObject_CallFunctionObjArgs(
+      reinterpret_cast<PyObject*>(&PyList_Type), self, nullptr));
+  if (list == nullptr) {
+    return nullptr;
+  }
+  return Py_TYPE(list.get())->tp_as_mapping->mp_subscript(list.get(), item);
+}
+
+// Returns the position of the item in the sequence, of -1 if not found.
+// This function never fails.
+int Find(PyContainer* self, PyObject* item) {
+  // The item can only be in one position: item.index.
+  // Check that self[item.index] == item, it's faster than a linear search.
+  //
+  // This assumes that sequences are only defined by syntax of the .proto file:
+  // a specific item belongs to only one sequence, depending on its position in
+  // the .proto file definition.
+  const void* descriptor_ptr = PyDescriptor_AsVoidPtr(item);
+  if (descriptor_ptr == nullptr) {
+    PyErr_Clear();
+    // Not a descriptor, it cannot be in the list.
+    return -1;
+  }
+  if (self->container_def->get_item_index_fn) {
+    int index = self->container_def->get_item_index_fn(descriptor_ptr);
+    if (index < 0 || index >= Length(self)) {
+      // This index is not from this collection.
+      return -1;
+    }
+    if (self->container_def->get_by_index_fn(self, index) != descriptor_ptr) {
+      // The descriptor at this index is not the same.
+      return -1;
+    }
+    // self[item.index] == item, so return the index.
+    return index;
+  } else {
+    // Fall back to linear search.
+    int length = Length(self);
+    for (int index=0; index < length; index++) {
+      if (self->container_def->get_by_index_fn(self, index) == descriptor_ptr) {
+        return index;
+      }
+    }
+    // Not found
+    return -1;
+  }
+}
+
+// Implements list.index(): the position of the item is in the sequence.
+static PyObject* Index(PyContainer* self, PyObject* item) {
+  int position = Find(self, item);
+  if (position < 0) {
+    // Not found
+    PyErr_SetNone(PyExc_ValueError);
+    return nullptr;
+  } else {
+    return PyLong_FromLong(position);
+  }
+}
+// Implements "list.__contains__()": is the object in the sequence.
+static int SeqContains(PyContainer* self, PyObject* item) {
+  int position = Find(self, item);
+  if (position < 0) {
+    return 0;
+  } else {
+    return 1;
+  }
+}
+
+// Implements list.count(): number of occurrences of the item in the sequence.
+// An item can only appear once in a sequence. If it exists, return 1.
+static PyObject* Count(PyContainer* self, PyObject* item) {
+  int position = Find(self, item);
+  if (position < 0) {
+    return PyLong_FromLong(0);
+  } else {
+    return PyLong_FromLong(1);
+  }
+}
+
+static PyObject* Append(PyContainer* self, PyObject* args) {
+  if (_CalledFromGeneratedFile(0)) {
+    Py_RETURN_NONE;
+  }
+  PyErr_Format(PyExc_TypeError,
+               "'%.200s' object is not a mutable sequence",
+               Py_TYPE(self)->tp_name);
+  return nullptr;
+}
+
+static PyObject* Reversed(PyContainer* self, PyObject* args) {
+  return NewContainerIterator(self,
+                              PyContainerIterator::KIND_ITERVALUE_REVERSED);
+}
+
+static PyMethodDef SeqMethods[] = {
+    {"index", (PyCFunction)Index, METH_O},
+    {"count", (PyCFunction)Count, METH_O},
+    {"append", (PyCFunction)Append, METH_O},
+    {"__reversed__", (PyCFunction)Reversed, METH_NOARGS},
+    {nullptr},
+};
+
+static PySequenceMethods SeqSequenceMethods = {
+    (lenfunc)Length,          // sq_length
+    nullptr,                  // sq_concat
+    nullptr,                  // sq_repeat
+    (ssizeargfunc)GetItem,    // sq_item
+    nullptr,                  // sq_slice
+    nullptr,                  // sq_ass_item
+    nullptr,                  // sq_ass_slice
+    (objobjproc)SeqContains,  // sq_contains
+};
+
+static PyMappingMethods SeqMappingMethods = {
+    (lenfunc)Length,           // mp_length
+    (binaryfunc)SeqSubscript,  // mp_subscript
+    nullptr,                   // mp_ass_subscript
+};
+
+PyTypeObject DescriptorSequence_Type = {
+    PyVarObject_HEAD_INIT(&PyType_Type, 0) "DescriptorSequence",  // tp_name
+    sizeof(PyContainer),  // tp_basicsize
+    0,                    // tp_itemsize
+    nullptr,              // tp_dealloc
+#if PY_VERSION_HEX < 0x03080000
+    nullptr,  // tp_print
+#else
+    0,  // tp_vectorcall_offset
+#endif
+    nullptr,                   // tp_getattr
+    nullptr,                   // tp_setattr
+    nullptr,                   // tp_compare
+    (reprfunc)ContainerRepr,   // tp_repr
+    nullptr,                   // tp_as_number
+    &SeqSequenceMethods,       // tp_as_sequence
+    &SeqMappingMethods,        // tp_as_mapping
+    nullptr,                   // tp_hash
+    nullptr,                   // tp_call
+    nullptr,                   // tp_str
+    nullptr,                   // tp_getattro
+    nullptr,                   // tp_setattro
+    nullptr,                   // tp_as_buffer
+    Py_TPFLAGS_DEFAULT,        // tp_flags
+    nullptr,                   // tp_doc
+    nullptr,                   // tp_traverse
+    nullptr,                   // tp_clear
+    (richcmpfunc)RichCompare,  // tp_richcompare
+    0,                         // tp_weaklistoffset
+    nullptr,                   // tp_iter
+    nullptr,                   // tp_iternext
+    SeqMethods,                // tp_methods
+    nullptr,                   // tp_members
+    nullptr,                   // tp_getset
+    nullptr,                   // tp_base
+    nullptr,                   // tp_dict
+    nullptr,                   // tp_descr_get
+    nullptr,                   // tp_descr_set
+    0,                         // tp_dictoffset
+    nullptr,                   // tp_init
+    nullptr,                   // tp_alloc
+    nullptr,                   // tp_new
+    nullptr,                   // tp_free
+};
+
+static PyObject* NewMappingByName(
+    DescriptorContainerDef* container_def, const void* descriptor) {
+  PyContainer* self = PyObject_New(PyContainer, &DescriptorMapping_Type);
+  if (self == nullptr) {
+    return nullptr;
+  }
+  self->descriptor = descriptor;
+  self->container_def = container_def;
+  self->kind = PyContainer::KIND_BYNAME;
+  return reinterpret_cast<PyObject*>(self);
+}
+
+static PyObject* NewMappingByCamelcaseName(
+    DescriptorContainerDef* container_def, const void* descriptor) {
+  PyContainer* self = PyObject_New(PyContainer, &DescriptorMapping_Type);
+  if (self == nullptr) {
+    return nullptr;
+  }
+  self->descriptor = descriptor;
+  self->container_def = container_def;
+  self->kind = PyContainer::KIND_BYCAMELCASENAME;
+  return reinterpret_cast<PyObject*>(self);
+}
+
+static PyObject* NewMappingByNumber(
+    DescriptorContainerDef* container_def, const void* descriptor) {
+  if (container_def->get_by_number_fn == nullptr ||
+      container_def->get_item_number_fn == nullptr) {
+    PyErr_SetNone(PyExc_NotImplementedError);
+    return nullptr;
+  }
+  PyContainer* self = PyObject_New(PyContainer, &DescriptorMapping_Type);
+  if (self == nullptr) {
+    return nullptr;
+  }
+  self->descriptor = descriptor;
+  self->container_def = container_def;
+  self->kind = PyContainer::KIND_BYNUMBER;
+  return reinterpret_cast<PyObject*>(self);
+}
+
+static PyObject* NewSequence(
+    DescriptorContainerDef* container_def, const void* descriptor) {
+  PyContainer* self = PyObject_New(PyContainer, &DescriptorSequence_Type);
+  if (self == nullptr) {
+    return nullptr;
+  }
+  self->descriptor = descriptor;
+  self->container_def = container_def;
+  self->kind = PyContainer::KIND_SEQUENCE;
+  return reinterpret_cast<PyObject*>(self);
+}
+
+// Implement iterators over PyContainers.
+
+static void Iterator_Dealloc(PyContainerIterator* self) {
+  Py_CLEAR(self->container);
+  Py_TYPE(self)->tp_free(reinterpret_cast<PyObject*>(self));
+}
+
+static PyObject* Iterator_Next(PyContainerIterator* self) {
+  int count = self->container->container_def->count_fn(self->container);
+  if (self->index >= count) {
+    // Return null with no exception to indicate the end.
+    return nullptr;
+  }
+  int index = self->index;
+  self->index += 1;
+  switch (self->kind) {
+    case PyContainerIterator::KIND_ITERKEY:
+      return _NewKey_ByIndex(self->container, index);
+    case PyContainerIterator::KIND_ITERVALUE:
+      return _NewObj_ByIndex(self->container, index);
+    case PyContainerIterator::KIND_ITERVALUE_REVERSED:
+      return _NewObj_ByIndex(self->container, count - index - 1);
+    case PyContainerIterator::KIND_ITERITEM: {
+      PyObject* obj = PyTuple_New(2);
+      if (obj == nullptr) {
+        return nullptr;
+      }
+      PyObject* key = _NewKey_ByIndex(self->container, index);
+      if (key == nullptr) {
+        Py_DECREF(obj);
+        return nullptr;
+      }
+      PyTuple_SET_ITEM(obj, 0, key);
+      PyObject* value = _NewObj_ByIndex(self->container, index);
+      if (value == nullptr) {
+        Py_DECREF(obj);
+        return nullptr;
+      }
+      PyTuple_SET_ITEM(obj, 1, value);
+      return obj;
+    }
+    default:
+      PyErr_SetNone(PyExc_NotImplementedError);
+      return nullptr;
+  }
+}
+
+static PyTypeObject ContainerIterator_Type = {
+    PyVarObject_HEAD_INIT(&PyType_Type,
+                          0) "DescriptorContainerIterator",  // tp_name
+    sizeof(PyContainerIterator),                             // tp_basicsize
+    0,                                                       // tp_itemsize
+    (destructor)Iterator_Dealloc,                            // tp_dealloc
+#if PY_VERSION_HEX < 0x03080000
+    nullptr,  // tp_print
+#else
+    0,  // tp_vectorcall_offset
+#endif
+    nullptr,                      // tp_getattr
+    nullptr,                      // tp_setattr
+    nullptr,                      // tp_compare
+    nullptr,                      // tp_repr
+    nullptr,                      // tp_as_number
+    nullptr,                      // tp_as_sequence
+    nullptr,                      // tp_as_mapping
+    nullptr,                      // tp_hash
+    nullptr,                      // tp_call
+    nullptr,                      // tp_str
+    nullptr,                      // tp_getattro
+    nullptr,                      // tp_setattro
+    nullptr,                      // tp_as_buffer
+    Py_TPFLAGS_DEFAULT,           // tp_flags
+    nullptr,                      // tp_doc
+    nullptr,                      // tp_traverse
+    nullptr,                      // tp_clear
+    nullptr,                      // tp_richcompare
+    0,                            // tp_weaklistoffset
+    PyObject_SelfIter,            // tp_iter
+    (iternextfunc)Iterator_Next,  // tp_iternext
+    nullptr,                      // tp_methods
+    nullptr,                      // tp_members
+    nullptr,                      // tp_getset
+    nullptr,                      // tp_base
+    nullptr,                      // tp_dict
+    nullptr,                      // tp_descr_get
+    nullptr,                      // tp_descr_set
+    0,                            // tp_dictoffset
+    nullptr,                      // tp_init
+    nullptr,                      // tp_alloc
+    nullptr,                      // tp_new
+    nullptr,                      // tp_free
+};
+
+static PyObject* NewContainerIterator(PyContainer* container,
+                                      PyContainerIterator::IterKind kind) {
+  PyContainerIterator* self = PyObject_New(PyContainerIterator,
+                                           &ContainerIterator_Type);
+  if (self == nullptr) {
+    return nullptr;
+  }
+  Py_INCREF(container);
+  self->container = container;
+  self->kind = kind;
+  self->index = 0;
+
+  return reinterpret_cast<PyObject*>(self);
+}
+
+}  // namespace descriptor
+
+// Now define the real collections!
+
+namespace message_descriptor {
+
+typedef const Descriptor* ParentDescriptor;
+
+static ParentDescriptor GetDescriptor(PyContainer* self) {
+  return reinterpret_cast<ParentDescriptor>(self->descriptor);
+}
+
+namespace fields {
+
+typedef const FieldDescriptor* ItemDescriptor;
+
+static int Count(PyContainer* self) {
+  return GetDescriptor(self)->field_count();
+}
+
+static const void* GetByName(PyContainer* self, ConstStringParam name) {
+  return GetDescriptor(self)->FindFieldByName(name);
+}
+
+static const void* GetByCamelcaseName(PyContainer* self,
+                                      ConstStringParam name) {
+  return GetDescriptor(self)->FindFieldByCamelcaseName(name);
+}
+
+static const void* GetByNumber(PyContainer* self, int number) {
+  return GetDescriptor(self)->FindFieldByNumber(number);
+}
+
+static const void* GetByIndex(PyContainer* self, int index) {
+  return GetDescriptor(self)->field(index);
+}
+
+static PyObject* NewObjectFromItem(const void* item) {
+  return PyFieldDescriptor_FromDescriptor(static_cast<ItemDescriptor>(item));
+}
+
+static const std::string& GetItemName(const void* item) {
+  return static_cast<ItemDescriptor>(item)->name();
+}
+
+static const std::string& GetItemCamelcaseName(const void* item) {
+  return static_cast<ItemDescriptor>(item)->camelcase_name();
+}
+
+static int GetItemNumber(const void* item) {
+  return static_cast<ItemDescriptor>(item)->number();
+}
+
+static int GetItemIndex(const void* item) {
+  return static_cast<ItemDescriptor>(item)->index();
+}
+
+static DescriptorContainerDef ContainerDef = {
+    "MessageFields",      Count,         GetByIndex,        GetByName,
+    GetByCamelcaseName,   GetByNumber,   NewObjectFromItem, GetItemName,
+    GetItemCamelcaseName, GetItemNumber, GetItemIndex,
+};
+
+}  // namespace fields
+
+PyObject* NewMessageFieldsByName(ParentDescriptor descriptor) {
+  return descriptor::NewMappingByName(&fields::ContainerDef, descriptor);
+}
+
+PyObject* NewMessageFieldsByCamelcaseName(ParentDescriptor descriptor) {
+  return descriptor::NewMappingByCamelcaseName(&fields::ContainerDef,
+                                               descriptor);
+}
+
+PyObject* NewMessageFieldsByNumber(ParentDescriptor descriptor) {
+  return descriptor::NewMappingByNumber(&fields::ContainerDef, descriptor);
+}
+
+PyObject* NewMessageFieldsSeq(ParentDescriptor descriptor) {
+  return descriptor::NewSequence(&fields::ContainerDef, descriptor);
+}
+
+namespace nested_types {
+
+typedef const Descriptor* ItemDescriptor;
+
+static int Count(PyContainer* self) {
+  return GetDescriptor(self)->nested_type_count();
+}
+
+static const void* GetByName(PyContainer* self, ConstStringParam name) {
+  return GetDescriptor(self)->FindNestedTypeByName(name);
+}
+
+static const void* GetByIndex(PyContainer* self, int index) {
+  return GetDescriptor(self)->nested_type(index);
+}
+
+static PyObject* NewObjectFromItem(const void* item) {
+  return PyMessageDescriptor_FromDescriptor(static_cast<ItemDescriptor>(item));
+}
+
+static const std::string& GetItemName(const void* item) {
+  return static_cast<ItemDescriptor>(item)->name();
+}
+
+static int GetItemIndex(const void* item) {
+  return static_cast<ItemDescriptor>(item)->index();
+}
+
+static DescriptorContainerDef ContainerDef = {
+    "MessageNestedTypes",
+    Count,
+    GetByIndex,
+    GetByName,
+    nullptr,
+    nullptr,
+    NewObjectFromItem,
+    GetItemName,
+    nullptr,
+    nullptr,
+    GetItemIndex,
+};
+
+}  // namespace nested_types
+
+PyObject* NewMessageNestedTypesSeq(ParentDescriptor descriptor) {
+  return descriptor::NewSequence(&nested_types::ContainerDef, descriptor);
+}
+
+PyObject* NewMessageNestedTypesByName(ParentDescriptor descriptor) {
+  return descriptor::NewMappingByName(&nested_types::ContainerDef, descriptor);
+}
+
+namespace enums {
+
+typedef const EnumDescriptor* ItemDescriptor;
+
+static int Count(PyContainer* self) {
+  return GetDescriptor(self)->enum_type_count();
+}
+
+static const void* GetByName(PyContainer* self, ConstStringParam name) {
+  return GetDescriptor(self)->FindEnumTypeByName(name);
+}
+
+static const void* GetByIndex(PyContainer* self, int index) {
+  return GetDescriptor(self)->enum_type(index);
+}
+
+static PyObject* NewObjectFromItem(const void* item) {
+  return PyEnumDescriptor_FromDescriptor(static_cast<ItemDescriptor>(item));
+}
+
+static const std::string& GetItemName(const void* item) {
+  return static_cast<ItemDescriptor>(item)->name();
+}
+
+static int GetItemIndex(const void* item) {
+  return static_cast<ItemDescriptor>(item)->index();
+}
+
+static DescriptorContainerDef ContainerDef = {
+    "MessageNestedEnums",
+    Count,
+    GetByIndex,
+    GetByName,
+    nullptr,
+    nullptr,
+    NewObjectFromItem,
+    GetItemName,
+    nullptr,
+    nullptr,
+    GetItemIndex,
+};
+
+}  // namespace enums
+
+PyObject* NewMessageEnumsByName(ParentDescriptor descriptor) {
+  return descriptor::NewMappingByName(&enums::ContainerDef, descriptor);
+}
+
+PyObject* NewMessageEnumsSeq(ParentDescriptor descriptor) {
+  return descriptor::NewSequence(&enums::ContainerDef, descriptor);
+}
+
+namespace enumvalues {
+
+// This is the "enum_values_by_name" mapping, which collects values from all
+// enum types in a message.
+//
+// Note that the behavior of the C++ descriptor is different: it will search and
+// return the first value that matches the name, whereas the Python
+// implementation retrieves the last one.
+
+typedef const EnumValueDescriptor* ItemDescriptor;
+
+static int Count(PyContainer* self) {
+  int count = 0;
+  for (int i = 0; i < GetDescriptor(self)->enum_type_count(); ++i) {
+    count += GetDescriptor(self)->enum_type(i)->value_count();
+  }
+  return count;
+}
+
+static const void* GetByName(PyContainer* self, ConstStringParam name) {
+  return GetDescriptor(self)->FindEnumValueByName(name);
+}
+
+static const void* GetByIndex(PyContainer* self, int index) {
+  // This is not optimal, but the number of enums *types* in a given message
+  // is small.  This function is only used when iterating over the mapping.
+  const EnumDescriptor* enum_type = nullptr;
+  int enum_type_count = GetDescriptor(self)->enum_type_count();
+  for (int i = 0; i < enum_type_count; ++i) {
+    enum_type = GetDescriptor(self)->enum_type(i);
+    int enum_value_count = enum_type->value_count();
+    if (index < enum_value_count) {
+      // Found it!
+      break;
+    }
+    index -= enum_value_count;
+  }
+  // The next statement cannot overflow, because this function is only called by
+  // internal iterators which ensure that 0 <= index < Count().
+  return enum_type->value(index);
+}
+
+static PyObject* NewObjectFromItem(const void* item) {
+  return PyEnumValueDescriptor_FromDescriptor(
+      static_cast<ItemDescriptor>(item));
+}
+
+static const std::string& GetItemName(const void* item) {
+  return static_cast<ItemDescriptor>(item)->name();
+}
+
+static DescriptorContainerDef ContainerDef = {
+    "MessageEnumValues", Count,       GetByIndex, GetByName, nullptr, nullptr,
+    NewObjectFromItem,   GetItemName, nullptr,    nullptr,   nullptr,
+};
+
+}  // namespace enumvalues
+
+PyObject* NewMessageEnumValuesByName(ParentDescriptor descriptor) {
+  return descriptor::NewMappingByName(&enumvalues::ContainerDef, descriptor);
+}
+
+namespace extensions {
+
+typedef const FieldDescriptor* ItemDescriptor;
+
+static int Count(PyContainer* self) {
+  return GetDescriptor(self)->extension_count();
+}
+
+static const void* GetByName(PyContainer* self, ConstStringParam name) {
+  return GetDescriptor(self)->FindExtensionByName(name);
+}
+
+static const void* GetByIndex(PyContainer* self, int index) {
+  return GetDescriptor(self)->extension(index);
+}
+
+static PyObject* NewObjectFromItem(const void* item) {
+  return PyFieldDescriptor_FromDescriptor(static_cast<ItemDescriptor>(item));
+}
+
+static const std::string& GetItemName(const void* item) {
+  return static_cast<ItemDescriptor>(item)->name();
+}
+
+static int GetItemIndex(const void* item) {
+  return static_cast<ItemDescriptor>(item)->index();
+}
+
+static DescriptorContainerDef ContainerDef = {
+    "MessageExtensions",
+    Count,
+    GetByIndex,
+    GetByName,
+    nullptr,
+    nullptr,
+    NewObjectFromItem,
+    GetItemName,
+    nullptr,
+    nullptr,
+    GetItemIndex,
+};
+
+}  // namespace extensions
+
+PyObject* NewMessageExtensionsByName(ParentDescriptor descriptor) {
+  return descriptor::NewMappingByName(&extensions::ContainerDef, descriptor);
+}
+
+PyObject* NewMessageExtensionsSeq(ParentDescriptor descriptor) {
+  return descriptor::NewSequence(&extensions::ContainerDef, descriptor);
+}
+
+namespace oneofs {
+
+typedef const OneofDescriptor* ItemDescriptor;
+
+static int Count(PyContainer* self) {
+  return GetDescriptor(self)->oneof_decl_count();
+}
+
+static const void* GetByName(PyContainer* self, ConstStringParam name) {
+  return GetDescriptor(self)->FindOneofByName(name);
+}
+
+static const void* GetByIndex(PyContainer* self, int index) {
+  return GetDescriptor(self)->oneof_decl(index);
+}
+
+static PyObject* NewObjectFromItem(const void* item) {
+  return PyOneofDescriptor_FromDescriptor(static_cast<ItemDescriptor>(item));
+}
+
+static const std::string& GetItemName(const void* item) {
+  return static_cast<ItemDescriptor>(item)->name();
+}
+
+static int GetItemIndex(const void* item) {
+  return static_cast<ItemDescriptor>(item)->index();
+}
+
+static DescriptorContainerDef ContainerDef = {
+    "MessageOneofs", Count,   GetByIndex,        GetByName,
+    nullptr,         nullptr, NewObjectFromItem, GetItemName,
+    nullptr,         nullptr, GetItemIndex,
+};
+
+}  // namespace oneofs
+
+PyObject* NewMessageOneofsByName(ParentDescriptor descriptor) {
+  return descriptor::NewMappingByName(&oneofs::ContainerDef, descriptor);
+}
+
+PyObject* NewMessageOneofsSeq(ParentDescriptor descriptor) {
+  return descriptor::NewSequence(&oneofs::ContainerDef, descriptor);
+}
+
+}  // namespace message_descriptor
+
+namespace enum_descriptor {
+
+typedef const EnumDescriptor* ParentDescriptor;
+
+static ParentDescriptor GetDescriptor(PyContainer* self) {
+  return reinterpret_cast<ParentDescriptor>(self->descriptor);
+}
+
+namespace enumvalues {
+
+typedef const EnumValueDescriptor* ItemDescriptor;
+
+static int Count(PyContainer* self) {
+  return GetDescriptor(self)->value_count();
+}
+
+static const void* GetByIndex(PyContainer* self, int index) {
+  return GetDescriptor(self)->value(index);
+}
+
+static const void* GetByName(PyContainer* self, ConstStringParam name) {
+  return GetDescriptor(self)->FindValueByName(name);
+}
+
+static const void* GetByNumber(PyContainer* self, int number) {
+  return GetDescriptor(self)->FindValueByNumber(number);
+}
+
+static PyObject* NewObjectFromItem(const void* item) {
+  return PyEnumValueDescriptor_FromDescriptor(
+      static_cast<ItemDescriptor>(item));
+}
+
+static const std::string& GetItemName(const void* item) {
+  return static_cast<ItemDescriptor>(item)->name();
+}
+
+static int GetItemNumber(const void* item) {
+  return static_cast<ItemDescriptor>(item)->number();
+}
+
+static int GetItemIndex(const void* item) {
+  return static_cast<ItemDescriptor>(item)->index();
+}
+
+static DescriptorContainerDef ContainerDef = {
+    "EnumValues", Count,         GetByIndex,        GetByName,
+    nullptr,      GetByNumber,   NewObjectFromItem, GetItemName,
+    nullptr,      GetItemNumber, GetItemIndex,
+};
+
+}  // namespace enumvalues
+
+PyObject* NewEnumValuesByName(ParentDescriptor descriptor) {
+  return descriptor::NewMappingByName(&enumvalues::ContainerDef, descriptor);
+}
+
+PyObject* NewEnumValuesByNumber(ParentDescriptor descriptor) {
+  return descriptor::NewMappingByNumber(&enumvalues::ContainerDef, descriptor);
+}
+
+PyObject* NewEnumValuesSeq(ParentDescriptor descriptor) {
+  return descriptor::NewSequence(&enumvalues::ContainerDef, descriptor);
+}
+
+}  // namespace enum_descriptor
+
+namespace oneof_descriptor {
+
+typedef const OneofDescriptor* ParentDescriptor;
+
+static ParentDescriptor GetDescriptor(PyContainer* self) {
+  return reinterpret_cast<ParentDescriptor>(self->descriptor);
+}
+
+namespace fields {
+
+typedef const FieldDescriptor* ItemDescriptor;
+
+static int Count(PyContainer* self) {
+  return GetDescriptor(self)->field_count();
+}
+
+static const void* GetByIndex(PyContainer* self, int index) {
+  return GetDescriptor(self)->field(index);
+}
+
+static PyObject* NewObjectFromItem(const void* item) {
+  return PyFieldDescriptor_FromDescriptor(static_cast<ItemDescriptor>(item));
+}
+
+static int GetItemIndex(const void* item) {
+  return static_cast<ItemDescriptor>(item)->index_in_oneof();
+}
+
+static DescriptorContainerDef ContainerDef = {
+    "OneofFields",     Count,   GetByIndex, nullptr, nullptr,      nullptr,
+    NewObjectFromItem, nullptr, nullptr,    nullptr, GetItemIndex,
+};
+
+}  // namespace fields
+
+PyObject* NewOneofFieldsSeq(ParentDescriptor descriptor) {
+  return descriptor::NewSequence(&fields::ContainerDef, descriptor);
+}
+
+}  // namespace oneof_descriptor
+
+namespace service_descriptor {
+
+typedef const ServiceDescriptor* ParentDescriptor;
+
+static ParentDescriptor GetDescriptor(PyContainer* self) {
+  return reinterpret_cast<ParentDescriptor>(self->descriptor);
+}
+
+namespace methods {
+
+typedef const MethodDescriptor* ItemDescriptor;
+
+static int Count(PyContainer* self) {
+  return GetDescriptor(self)->method_count();
+}
+
+static const void* GetByName(PyContainer* self, ConstStringParam name) {
+  return GetDescriptor(self)->FindMethodByName(name);
+}
+
+static const void* GetByIndex(PyContainer* self, int index) {
+  return GetDescriptor(self)->method(index);
+}
+
+static PyObject* NewObjectFromItem(const void* item) {
+  return PyMethodDescriptor_FromDescriptor(static_cast<ItemDescriptor>(item));
+}
+
+static const std::string& GetItemName(const void* item) {
+  return static_cast<ItemDescriptor>(item)->name();
+}
+
+static int GetItemIndex(const void* item) {
+  return static_cast<ItemDescriptor>(item)->index();
+}
+
+static DescriptorContainerDef ContainerDef = {
+    "ServiceMethods", Count,   GetByIndex,        GetByName,
+    nullptr,          nullptr, NewObjectFromItem, GetItemName,
+    nullptr,          nullptr, GetItemIndex,
+};
+
+}  // namespace methods
+
+PyObject* NewServiceMethodsSeq(ParentDescriptor descriptor) {
+  return descriptor::NewSequence(&methods::ContainerDef, descriptor);
+}
+
+PyObject* NewServiceMethodsByName(ParentDescriptor descriptor) {
+  return descriptor::NewMappingByName(&methods::ContainerDef, descriptor);
+}
+
+}  // namespace service_descriptor
+
+namespace file_descriptor {
+
+typedef const FileDescriptor* ParentDescriptor;
+
+static ParentDescriptor GetDescriptor(PyContainer* self) {
+  return reinterpret_cast<ParentDescriptor>(self->descriptor);
+}
+
+namespace messages {
+
+typedef const Descriptor* ItemDescriptor;
+
+static int Count(PyContainer* self) {
+  return GetDescriptor(self)->message_type_count();
+}
+
+static const void* GetByName(PyContainer* self, ConstStringParam name) {
+  return GetDescriptor(self)->FindMessageTypeByName(name);
+}
+
+static const void* GetByIndex(PyContainer* self, int index) {
+  return GetDescriptor(self)->message_type(index);
+}
+
+static PyObject* NewObjectFromItem(const void* item) {
+  return PyMessageDescriptor_FromDescriptor(static_cast<ItemDescriptor>(item));
+}
+
+static const std::string& GetItemName(const void* item) {
+  return static_cast<ItemDescriptor>(item)->name();
+}
+
+static int GetItemIndex(const void* item) {
+  return static_cast<ItemDescriptor>(item)->index();
+}
+
+static DescriptorContainerDef ContainerDef = {
+    "FileMessages", Count,   GetByIndex,        GetByName,
+    nullptr,        nullptr, NewObjectFromItem, GetItemName,
+    nullptr,        nullptr, GetItemIndex,
+};
+
+}  // namespace messages
+
+PyObject* NewFileMessageTypesByName(ParentDescriptor descriptor) {
+  return descriptor::NewMappingByName(&messages::ContainerDef, descriptor);
+}
+
+namespace enums {
+
+typedef const EnumDescriptor* ItemDescriptor;
+
+static int Count(PyContainer* self) {
+  return GetDescriptor(self)->enum_type_count();
+}
+
+static const void* GetByName(PyContainer* self, ConstStringParam name) {
+  return GetDescriptor(self)->FindEnumTypeByName(name);
+}
+
+static const void* GetByIndex(PyContainer* self, int index) {
+  return GetDescriptor(self)->enum_type(index);
+}
+
+static PyObject* NewObjectFromItem(const void* item) {
+  return PyEnumDescriptor_FromDescriptor(static_cast<ItemDescriptor>(item));
+}
+
+static const std::string& GetItemName(const void* item) {
+  return static_cast<ItemDescriptor>(item)->name();
+}
+
+static int GetItemIndex(const void* item) {
+  return static_cast<ItemDescriptor>(item)->index();
+}
+
+static DescriptorContainerDef ContainerDef = {
+    "FileEnums", Count,   GetByIndex,        GetByName,
+    nullptr,     nullptr, NewObjectFromItem, GetItemName,
+    nullptr,     nullptr, GetItemIndex,
+};
+
+}  // namespace enums
+
+PyObject* NewFileEnumTypesByName(ParentDescriptor descriptor) {
+  return descriptor::NewMappingByName(&enums::ContainerDef, descriptor);
+}
+
+namespace extensions {
+
+typedef const FieldDescriptor* ItemDescriptor;
+
+static int Count(PyContainer* self) {
+  return GetDescriptor(self)->extension_count();
+}
+
+static const void* GetByName(PyContainer* self, ConstStringParam name) {
+  return GetDescriptor(self)->FindExtensionByName(name);
+}
+
+static const void* GetByIndex(PyContainer* self, int index) {
+  return GetDescriptor(self)->extension(index);
+}
+
+static PyObject* NewObjectFromItem(const void* item) {
+  return PyFieldDescriptor_FromDescriptor(static_cast<ItemDescriptor>(item));
+}
+
+static const std::string& GetItemName(const void* item) {
+  return static_cast<ItemDescriptor>(item)->name();
+}
+
+static int GetItemIndex(const void* item) {
+  return static_cast<ItemDescriptor>(item)->index();
+}
+
+static DescriptorContainerDef ContainerDef = {
+    "FileExtensions", Count,   GetByIndex,        GetByName,
+    nullptr,          nullptr, NewObjectFromItem, GetItemName,
+    nullptr,          nullptr, GetItemIndex,
+};
+
+}  // namespace extensions
+
+PyObject* NewFileExtensionsByName(ParentDescriptor descriptor) {
+  return descriptor::NewMappingByName(&extensions::ContainerDef, descriptor);
+}
+
+namespace services {
+
+typedef const ServiceDescriptor* ItemDescriptor;
+
+static int Count(PyContainer* self) {
+  return GetDescriptor(self)->service_count();
+}
+
+static const void* GetByName(PyContainer* self, ConstStringParam name) {
+  return GetDescriptor(self)->FindServiceByName(name);
+}
+
+static const void* GetByIndex(PyContainer* self, int index) {
+  return GetDescriptor(self)->service(index);
+}
+
+static PyObject* NewObjectFromItem(const void* item) {
+  return PyServiceDescriptor_FromDescriptor(static_cast<ItemDescriptor>(item));
+}
+
+static const std::string& GetItemName(const void* item) {
+  return static_cast<ItemDescriptor>(item)->name();
+}
+
+static int GetItemIndex(const void* item) {
+  return static_cast<ItemDescriptor>(item)->index();
+}
+
+static DescriptorContainerDef ContainerDef = {
+    "FileServices", Count,   GetByIndex,        GetByName,
+    nullptr,        nullptr, NewObjectFromItem, GetItemName,
+    nullptr,        nullptr, GetItemIndex,
+};
+
+}  // namespace services
+
+PyObject* NewFileServicesByName(const FileDescriptor* descriptor) {
+  return descriptor::NewMappingByName(&services::ContainerDef, descriptor);
+}
+
+namespace dependencies {
+
+typedef const FileDescriptor* ItemDescriptor;
+
+static int Count(PyContainer* self) {
+  return GetDescriptor(self)->dependency_count();
+}
+
+static const void* GetByIndex(PyContainer* self, int index) {
+  return GetDescriptor(self)->dependency(index);
+}
+
+static PyObject* NewObjectFromItem(const void* item) {
+  return PyFileDescriptor_FromDescriptor(static_cast<ItemDescriptor>(item));
+}
+
+static DescriptorContainerDef ContainerDef = {
+    "FileDependencies", Count,   GetByIndex, nullptr, nullptr, nullptr,
+    NewObjectFromItem,  nullptr, nullptr,    nullptr, nullptr,
+};
+
+}  // namespace dependencies
+
+PyObject* NewFileDependencies(const FileDescriptor* descriptor) {
+  return descriptor::NewSequence(&dependencies::ContainerDef, descriptor);
+}
+
+namespace public_dependencies {
+
+typedef const FileDescriptor* ItemDescriptor;
+
+static int Count(PyContainer* self) {
+  return GetDescriptor(self)->public_dependency_count();
+}
+
+static const void* GetByIndex(PyContainer* self, int index) {
+  return GetDescriptor(self)->public_dependency(index);
+}
+
+static PyObject* NewObjectFromItem(const void* item) {
+  return PyFileDescriptor_FromDescriptor(static_cast<ItemDescriptor>(item));
+}
+
+static DescriptorContainerDef ContainerDef = {
+    "FilePublicDependencies", Count,   GetByIndex, nullptr, nullptr, nullptr,
+    NewObjectFromItem,        nullptr, nullptr,    nullptr, nullptr,
+};
+
+}  // namespace public_dependencies
+
+PyObject* NewFilePublicDependencies(const FileDescriptor* descriptor) {
+  return descriptor::NewSequence(&public_dependencies::ContainerDef,
+                                 descriptor);
+}
+
+}  // namespace file_descriptor
+
+
+// Register all implementations
+
+bool InitDescriptorMappingTypes() {
+  if (PyType_Ready(&descriptor::DescriptorMapping_Type) < 0)
+    return false;
+  if (PyType_Ready(&descriptor::DescriptorSequence_Type) < 0)
+    return false;
+  if (PyType_Ready(&descriptor::ContainerIterator_Type) < 0)
+    return false;
+  return true;
+}
+
+}  // namespace python
+}  // namespace protobuf
+}  // namespace google
diff --git a/lark_channel/ws/pb/google/protobuf/pyext/descriptor_containers.h b/lark_channel/ws/pb/google/protobuf/pyext/descriptor_containers.h
new file mode 100644
index 0000000..cf2cf4a
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/pyext/descriptor_containers.h
@@ -0,0 +1,110 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_PYTHON_CPP_DESCRIPTOR_CONTAINERS_H__
+#define GOOGLE_PROTOBUF_PYTHON_CPP_DESCRIPTOR_CONTAINERS_H__
+
+// Mappings and Sequences of descriptors.
+// They implement containers like fields_by_name, EnumDescriptor.values...
+// See descriptor_containers.cc for more description.
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+namespace google {
+namespace protobuf {
+
+class Descriptor;
+class FileDescriptor;
+class EnumDescriptor;
+class OneofDescriptor;
+class ServiceDescriptor;
+
+namespace python {
+
+// Initialize the various types and objects.
+bool InitDescriptorMappingTypes();
+
+// Each function below returns a Mapping, or a Sequence of descriptors.
+// They all return a new reference.
+
+namespace message_descriptor {
+PyObject* NewMessageFieldsByName(const Descriptor* descriptor);
+PyObject* NewMessageFieldsByCamelcaseName(const Descriptor* descriptor);
+PyObject* NewMessageFieldsByNumber(const Descriptor* descriptor);
+PyObject* NewMessageFieldsSeq(const Descriptor* descriptor);
+
+PyObject* NewMessageNestedTypesSeq(const Descriptor* descriptor);
+PyObject* NewMessageNestedTypesByName(const Descriptor* descriptor);
+
+PyObject* NewMessageEnumsByName(const Descriptor* descriptor);
+PyObject* NewMessageEnumsSeq(const Descriptor* descriptor);
+PyObject* NewMessageEnumValuesByName(const Descriptor* descriptor);
+
+PyObject* NewMessageExtensionsByName(const Descriptor* descriptor);
+PyObject* NewMessageExtensionsSeq(const Descriptor* descriptor);
+
+PyObject* NewMessageOneofsByName(const Descriptor* descriptor);
+PyObject* NewMessageOneofsSeq(const Descriptor* descriptor);
+}  // namespace message_descriptor
+
+namespace enum_descriptor {
+PyObject* NewEnumValuesByName(const EnumDescriptor* descriptor);
+PyObject* NewEnumValuesByNumber(const EnumDescriptor* descriptor);
+PyObject* NewEnumValuesSeq(const EnumDescriptor* descriptor);
+}  // namespace enum_descriptor
+
+namespace oneof_descriptor {
+PyObject* NewOneofFieldsSeq(const OneofDescriptor* descriptor);
+}  // namespace oneof_descriptor
+
+namespace file_descriptor {
+PyObject* NewFileMessageTypesByName(const FileDescriptor* descriptor);
+
+PyObject* NewFileEnumTypesByName(const FileDescriptor* descriptor);
+
+PyObject* NewFileExtensionsByName(const FileDescriptor* descriptor);
+
+PyObject* NewFileServicesByName(const FileDescriptor* descriptor);
+
+PyObject* NewFileDependencies(const FileDescriptor* descriptor);
+PyObject* NewFilePublicDependencies(const FileDescriptor* descriptor);
+}  // namespace file_descriptor
+
+namespace service_descriptor {
+PyObject* NewServiceMethodsSeq(const ServiceDescriptor* descriptor);
+PyObject* NewServiceMethodsByName(const ServiceDescriptor* descriptor);
+}  // namespace service_descriptor
+
+
+}  // namespace python
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_PYTHON_CPP_DESCRIPTOR_CONTAINERS_H__
diff --git a/lark_channel/ws/pb/google/protobuf/pyext/descriptor_database.cc b/lark_channel/ws/pb/google/protobuf/pyext/descriptor_database.cc
new file mode 100644
index 0000000..f87f23d
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/pyext/descriptor_database.cc
@@ -0,0 +1,187 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This file defines a C++ DescriptorDatabase, which wraps a Python Database
+// and delegate all its operations to Python methods.
+
+#include <google/protobuf/pyext/descriptor_database.h>
+
+#include <cstdint>
+
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/descriptor.pb.h>
+#include <google/protobuf/pyext/message.h>
+#include <google/protobuf/pyext/scoped_pyobject_ptr.h>
+
+namespace google {
+namespace protobuf {
+namespace python {
+
+PyDescriptorDatabase::PyDescriptorDatabase(PyObject* py_database)
+    : py_database_(py_database) {
+  Py_INCREF(py_database_);
+}
+
+PyDescriptorDatabase::~PyDescriptorDatabase() { Py_DECREF(py_database_); }
+
+// Convert a Python object to a FileDescriptorProto pointer.
+// Handles all kinds of Python errors, which are simply logged.
+static bool GetFileDescriptorProto(PyObject* py_descriptor,
+                                   FileDescriptorProto* output) {
+  if (py_descriptor == nullptr) {
+    if (PyErr_ExceptionMatches(PyExc_KeyError)) {
+      // Expected error: item was simply not found.
+      PyErr_Clear();
+    } else {
+      GOOGLE_LOG(ERROR) << "DescriptorDatabase method raised an error";
+      PyErr_Print();
+    }
+    return false;
+  }
+  if (py_descriptor == Py_None) {
+    return false;
+  }
+  const Descriptor* filedescriptor_descriptor =
+      FileDescriptorProto::default_instance().GetDescriptor();
+  CMessage* message = reinterpret_cast<CMessage*>(py_descriptor);
+  if (PyObject_TypeCheck(py_descriptor, CMessage_Type) &&
+      message->message->GetDescriptor() == filedescriptor_descriptor) {
+    // Fast path: Just use the pointer.
+    FileDescriptorProto* file_proto =
+        static_cast<FileDescriptorProto*>(message->message);
+    *output = *file_proto;
+    return true;
+  } else {
+    // Slow path: serialize the message. This allows to use databases which
+    // use a different implementation of FileDescriptorProto.
+    ScopedPyObjectPtr serialized_pb(
+        PyObject_CallMethod(py_descriptor, "SerializeToString", nullptr));
+    if (serialized_pb == nullptr) {
+      GOOGLE_LOG(ERROR)
+          << "DescriptorDatabase method did not return a FileDescriptorProto";
+      PyErr_Print();
+      return false;
+    }
+    char* str;
+    Py_ssize_t len;
+    if (PyBytes_AsStringAndSize(serialized_pb.get(), &str, &len) < 0) {
+      GOOGLE_LOG(ERROR)
+          << "DescriptorDatabase method did not return a FileDescriptorProto";
+      PyErr_Print();
+      return false;
+    }
+    FileDescriptorProto file_proto;
+    if (!file_proto.ParseFromArray(str, len)) {
+      GOOGLE_LOG(ERROR)
+          << "DescriptorDatabase method did not return a FileDescriptorProto";
+      return false;
+    }
+    *output = file_proto;
+    return true;
+  }
+}
+
+// Find a file by file name.
+bool PyDescriptorDatabase::FindFileByName(const std::string& filename,
+                                          FileDescriptorProto* output) {
+  ScopedPyObjectPtr py_descriptor(PyObject_CallMethod(
+      py_database_, "FindFileByName", "s#", filename.c_str(), filename.size()));
+  return GetFileDescriptorProto(py_descriptor.get(), output);
+}
+
+// Find the file that declares the given fully-qualified symbol name.
+bool PyDescriptorDatabase::FindFileContainingSymbol(
+    const std::string& symbol_name, FileDescriptorProto* output) {
+  ScopedPyObjectPtr py_descriptor(
+      PyObject_CallMethod(py_database_, "FindFileContainingSymbol", "s#",
+                          symbol_name.c_str(), symbol_name.size()));
+  return GetFileDescriptorProto(py_descriptor.get(), output);
+}
+
+// Find the file which defines an extension extending the given message type
+// with the given field number.
+// Python DescriptorDatabases are not required to implement this method.
+bool PyDescriptorDatabase::FindFileContainingExtension(
+    const std::string& containing_type, int field_number,
+    FileDescriptorProto* output) {
+  ScopedPyObjectPtr py_method(
+      PyObject_GetAttrString(py_database_, "FindFileContainingExtension"));
+  if (py_method == nullptr) {
+    // This method is not implemented, returns without error.
+    PyErr_Clear();
+    return false;
+  }
+  ScopedPyObjectPtr py_descriptor(
+      PyObject_CallFunction(py_method.get(), "s#i", containing_type.c_str(),
+                            containing_type.size(), field_number));
+  return GetFileDescriptorProto(py_descriptor.get(), output);
+}
+
+// Finds the tag numbers used by all known extensions of
+// containing_type, and appends them to output in an undefined
+// order.
+// Python DescriptorDatabases are not required to implement this method.
+bool PyDescriptorDatabase::FindAllExtensionNumbers(
+    const std::string& containing_type, std::vector<int>* output) {
+  ScopedPyObjectPtr py_method(
+      PyObject_GetAttrString(py_database_, "FindAllExtensionNumbers"));
+  if (py_method == nullptr) {
+    // This method is not implemented, returns without error.
+    PyErr_Clear();
+    return false;
+  }
+  ScopedPyObjectPtr py_list(
+      PyObject_CallFunction(py_method.get(), "s#", containing_type.c_str(),
+                            containing_type.size()));
+  if (py_list == nullptr) {
+    PyErr_Print();
+    return false;
+  }
+  Py_ssize_t size = PyList_Size(py_list.get());
+  int64_t item_value;
+  for (Py_ssize_t i = 0 ; i < size; ++i) {
+    ScopedPyObjectPtr item(PySequence_GetItem(py_list.get(), i));
+    item_value = PyLong_AsLong(item.get());
+    if (item_value < 0) {
+      GOOGLE_LOG(ERROR)
+          << "FindAllExtensionNumbers method did not return "
+          << "valid extension numbers.";
+      PyErr_Print();
+      return false;
+    }
+    output->push_back(item_value);
+  }
+  return true;
+}
+
+}  // namespace python
+}  // namespace protobuf
+}  // namespace google
diff --git a/lark_channel/ws/pb/google/protobuf/pyext/descriptor_database.h b/lark_channel/ws/pb/google/protobuf/pyext/descriptor_database.h
new file mode 100644
index 0000000..5621a22
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/pyext/descriptor_database.h
@@ -0,0 +1,83 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_PYTHON_CPP_DESCRIPTOR_DATABASE_H__
+#define GOOGLE_PROTOBUF_PYTHON_CPP_DESCRIPTOR_DATABASE_H__
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+#include <google/protobuf/descriptor_database.h>
+
+namespace google {
+namespace protobuf {
+namespace python {
+
+class PyDescriptorDatabase : public DescriptorDatabase {
+ public:
+  explicit PyDescriptorDatabase(PyObject* py_database);
+  ~PyDescriptorDatabase() override;
+
+  // Implement the abstract interface. All these functions fill the output
+  // with a copy of FileDescriptorProto.
+
+  // Find a file by file name.
+  bool FindFileByName(const std::string& filename,
+                      FileDescriptorProto* output) override;
+
+  // Find the file that declares the given fully-qualified symbol name.
+  bool FindFileContainingSymbol(const std::string& symbol_name,
+                                FileDescriptorProto* output) override;
+
+  // Find the file which defines an extension extending the given message type
+  // with the given field number.
+  // Containing_type must be a fully-qualified type name.
+  // Python objects are not required to implement this method.
+  bool FindFileContainingExtension(const std::string& containing_type,
+                                   int field_number,
+                                   FileDescriptorProto* output) override;
+
+  // Finds the tag numbers used by all known extensions of
+  // containing_type, and appends them to output in an undefined
+  // order.
+  // Python objects are not required to implement this method.
+  bool FindAllExtensionNumbers(const std::string& containing_type,
+                               std::vector<int>* output) override;
+
+ private:
+  // The python object that implements the database. The reference is owned.
+  PyObject* py_database_;
+};
+
+}  // namespace python
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_PYTHON_CPP_DESCRIPTOR_DATABASE_H__
diff --git a/lark_channel/ws/pb/google/protobuf/pyext/descriptor_pool.cc b/lark_channel/ws/pb/google/protobuf/pyext/descriptor_pool.cc
new file mode 100644
index 0000000..2f39281
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/pyext/descriptor_pool.cc
@@ -0,0 +1,817 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Implements the DescriptorPool, which collects all descriptors.
+
+#include <unordered_map>
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+#include <google/protobuf/descriptor.pb.h>
+#include <google/protobuf/pyext/descriptor.h>
+#include <google/protobuf/pyext/descriptor_database.h>
+#include <google/protobuf/pyext/descriptor_pool.h>
+#include <google/protobuf/pyext/message.h>
+#include <google/protobuf/pyext/message_factory.h>
+#include <google/protobuf/pyext/scoped_pyobject_ptr.h>
+#include <google/protobuf/stubs/hash.h>
+
+#define PyString_AsStringAndSize(ob, charpp, sizep)              \
+  (PyUnicode_Check(ob)                                           \
+       ? ((*(charpp) = const_cast<char*>(                        \
+               PyUnicode_AsUTF8AndSize(ob, (sizep)))) == nullptr \
+              ? -1                                               \
+              : 0)                                               \
+       : PyBytes_AsStringAndSize(ob, (charpp), (sizep)))
+
+namespace google {
+namespace protobuf {
+namespace python {
+
+// A map to cache Python Pools per C++ pointer.
+// Pointers are not owned here, and belong to the PyDescriptorPool.
+static std::unordered_map<const DescriptorPool*, PyDescriptorPool*>*
+    descriptor_pool_map;
+
+namespace cdescriptor_pool {
+
+// Collects errors that occur during proto file building to allow them to be
+// propagated in the python exception instead of only living in ERROR logs.
+class BuildFileErrorCollector : public DescriptorPool::ErrorCollector {
+ public:
+  BuildFileErrorCollector() : error_message(""), had_errors_(false) {}
+
+  void AddError(const std::string& filename, const std::string& element_name,
+                const Message* descriptor, ErrorLocation location,
+                const std::string& message) override {
+    // Replicates the logging behavior that happens in the C++ implementation
+    // when an error collector is not passed in.
+    if (!had_errors_) {
+      error_message +=
+          ("Invalid proto descriptor for file \"" + filename + "\":\n");
+      had_errors_ = true;
+    }
+    // As this only happens on failure and will result in the program not
+    // running at all, no effort is made to optimize this string manipulation.
+    error_message += ("  " + element_name + ": " + message + "\n");
+  }
+
+  void Clear() {
+    had_errors_ = false;
+    error_message = "";
+  }
+
+  std::string error_message;
+
+ private:
+  bool had_errors_;
+};
+
+// Create a Python DescriptorPool object, but does not fill the "pool"
+// attribute.
+static PyDescriptorPool* _CreateDescriptorPool() {
+  PyDescriptorPool* cpool = PyObject_GC_New(
+      PyDescriptorPool, &PyDescriptorPool_Type);
+  if (cpool == nullptr) {
+    return nullptr;
+  }
+
+  cpool->error_collector = nullptr;
+  cpool->underlay = nullptr;
+  cpool->database = nullptr;
+  cpool->is_owned = false;
+  cpool->is_mutable = false;
+
+  cpool->descriptor_options = new std::unordered_map<const void*, PyObject*>();
+
+  cpool->py_message_factory = message_factory::NewMessageFactory(
+      &PyMessageFactory_Type, cpool);
+  if (cpool->py_message_factory == nullptr) {
+    Py_DECREF(cpool);
+    return nullptr;
+  }
+
+  PyObject_GC_Track(cpool);
+
+  return cpool;
+}
+
+// Create a Python DescriptorPool, using the given pool as an underlay:
+// new messages will be added to a custom pool, not to the underlay.
+//
+// Ownership of the underlay is not transferred, its pointer should
+// stay alive.
+static PyDescriptorPool* PyDescriptorPool_NewWithUnderlay(
+    const DescriptorPool* underlay) {
+  PyDescriptorPool* cpool = _CreateDescriptorPool();
+  if (cpool == nullptr) {
+    return nullptr;
+  }
+  cpool->pool = new DescriptorPool(underlay);
+  cpool->is_owned = true;
+  cpool->is_mutable = true;
+  cpool->underlay = underlay;
+
+  if (!descriptor_pool_map->insert(
+      std::make_pair(cpool->pool, cpool)).second) {
+    // Should never happen -- would indicate an internal error / bug.
+    PyErr_SetString(PyExc_ValueError, "DescriptorPool already registered");
+    return nullptr;
+  }
+
+  return cpool;
+}
+
+static PyDescriptorPool* PyDescriptorPool_NewWithDatabase(
+    DescriptorDatabase* database) {
+  PyDescriptorPool* cpool = _CreateDescriptorPool();
+  if (cpool == nullptr) {
+    return nullptr;
+  }
+  if (database != nullptr) {
+    cpool->error_collector = new BuildFileErrorCollector();
+    cpool->pool = new DescriptorPool(database, cpool->error_collector);
+    cpool->is_mutable = false;
+    cpool->database = database;
+  } else {
+    cpool->pool = new DescriptorPool();
+    cpool->is_mutable = true;
+  }
+  cpool->is_owned = true;
+
+  if (!descriptor_pool_map->insert(std::make_pair(cpool->pool, cpool)).second) {
+    // Should never happen -- would indicate an internal error / bug.
+    PyErr_SetString(PyExc_ValueError, "DescriptorPool already registered");
+    return nullptr;
+  }
+
+  return cpool;
+}
+
+// The public DescriptorPool constructor.
+static PyObject* New(PyTypeObject* type,
+                     PyObject* args, PyObject* kwargs) {
+  static const char* kwlist[] = {"descriptor_db", nullptr};
+  PyObject* py_database = nullptr;
+  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O",
+                                   const_cast<char**>(kwlist), &py_database)) {
+    return nullptr;
+  }
+  DescriptorDatabase* database = nullptr;
+  if (py_database && py_database != Py_None) {
+    database = new PyDescriptorDatabase(py_database);
+  }
+  return reinterpret_cast<PyObject*>(
+      PyDescriptorPool_NewWithDatabase(database));
+}
+
+static void Dealloc(PyObject* pself) {
+  PyDescriptorPool* self = reinterpret_cast<PyDescriptorPool*>(pself);
+  descriptor_pool_map->erase(self->pool);
+  Py_CLEAR(self->py_message_factory);
+  for (std::unordered_map<const void*, PyObject*>::iterator it =
+           self->descriptor_options->begin();
+       it != self->descriptor_options->end(); ++it) {
+    Py_DECREF(it->second);
+  }
+  delete self->descriptor_options;
+  delete self->database;
+  if (self->is_owned) {
+    delete self->pool;
+  }
+  delete self->error_collector;
+  Py_TYPE(self)->tp_free(pself);
+}
+
+static int GcTraverse(PyObject* pself, visitproc visit, void* arg) {
+  PyDescriptorPool* self = reinterpret_cast<PyDescriptorPool*>(pself);
+  Py_VISIT(self->py_message_factory);
+  return 0;
+}
+
+static int GcClear(PyObject* pself) {
+  PyDescriptorPool* self = reinterpret_cast<PyDescriptorPool*>(pself);
+  Py_CLEAR(self->py_message_factory);
+  return 0;
+}
+
+PyObject* SetErrorFromCollector(DescriptorPool::ErrorCollector* self,
+                                const char* name, const char* error_type) {
+  BuildFileErrorCollector* error_collector =
+      reinterpret_cast<BuildFileErrorCollector*>(self);
+  if (error_collector && !error_collector->error_message.empty()) {
+    PyErr_Format(PyExc_KeyError, "Couldn't build file for %s %.200s\n%s",
+                 error_type, name, error_collector->error_message.c_str());
+    error_collector->Clear();
+    return nullptr;
+  }
+  PyErr_Format(PyExc_KeyError, "Couldn't find %s %.200s", error_type, name);
+  return nullptr;
+}
+
+static PyObject* FindMessageByName(PyObject* self, PyObject* arg) {
+  Py_ssize_t name_size;
+  char* name;
+  if (PyString_AsStringAndSize(arg, &name, &name_size) < 0) {
+    return nullptr;
+  }
+
+  const Descriptor* message_descriptor =
+      reinterpret_cast<PyDescriptorPool*>(self)->pool->FindMessageTypeByName(
+          StringParam(name, name_size));
+
+  if (message_descriptor == nullptr) {
+    return SetErrorFromCollector(
+        reinterpret_cast<PyDescriptorPool*>(self)->error_collector, name,
+        "message");
+  }
+
+
+  return PyMessageDescriptor_FromDescriptor(message_descriptor);
+}
+
+
+
+
+static PyObject* FindFileByName(PyObject* self, PyObject* arg) {
+  Py_ssize_t name_size;
+  char* name;
+  if (PyString_AsStringAndSize(arg, &name, &name_size) < 0) {
+    return nullptr;
+  }
+
+  PyDescriptorPool* py_pool = reinterpret_cast<PyDescriptorPool*>(self);
+  const FileDescriptor* file_descriptor =
+      py_pool->pool->FindFileByName(StringParam(name, name_size));
+
+  if (file_descriptor == nullptr) {
+    return SetErrorFromCollector(py_pool->error_collector, name, "file");
+  }
+  return PyFileDescriptor_FromDescriptor(file_descriptor);
+}
+
+PyObject* FindFieldByName(PyDescriptorPool* self, PyObject* arg) {
+  Py_ssize_t name_size;
+  char* name;
+  if (PyString_AsStringAndSize(arg, &name, &name_size) < 0) {
+    return nullptr;
+  }
+
+  const FieldDescriptor* field_descriptor =
+      self->pool->FindFieldByName(StringParam(name, name_size));
+  if (field_descriptor == nullptr) {
+    return SetErrorFromCollector(self->error_collector, name, "field");
+  }
+
+
+  return PyFieldDescriptor_FromDescriptor(field_descriptor);
+}
+
+static PyObject* FindFieldByNameMethod(PyObject* self, PyObject* arg) {
+  return FindFieldByName(reinterpret_cast<PyDescriptorPool*>(self), arg);
+}
+
+PyObject* FindExtensionByName(PyDescriptorPool* self, PyObject* arg) {
+  Py_ssize_t name_size;
+  char* name;
+  if (PyString_AsStringAndSize(arg, &name, &name_size) < 0) {
+    return nullptr;
+  }
+
+  const FieldDescriptor* field_descriptor =
+      self->pool->FindExtensionByName(StringParam(name, name_size));
+  if (field_descriptor == nullptr) {
+    return SetErrorFromCollector(self->error_collector, name,
+                                 "extension field");
+  }
+
+
+  return PyFieldDescriptor_FromDescriptor(field_descriptor);
+}
+
+static PyObject* FindExtensionByNameMethod(PyObject* self, PyObject* arg) {
+  return FindExtensionByName(reinterpret_cast<PyDescriptorPool*>(self), arg);
+}
+
+PyObject* FindEnumTypeByName(PyDescriptorPool* self, PyObject* arg) {
+  Py_ssize_t name_size;
+  char* name;
+  if (PyString_AsStringAndSize(arg, &name, &name_size) < 0) {
+    return nullptr;
+  }
+
+  const EnumDescriptor* enum_descriptor =
+      self->pool->FindEnumTypeByName(StringParam(name, name_size));
+  if (enum_descriptor == nullptr) {
+    return SetErrorFromCollector(self->error_collector, name, "enum");
+  }
+
+
+  return PyEnumDescriptor_FromDescriptor(enum_descriptor);
+}
+
+static PyObject* FindEnumTypeByNameMethod(PyObject* self, PyObject* arg) {
+  return FindEnumTypeByName(reinterpret_cast<PyDescriptorPool*>(self), arg);
+}
+
+PyObject* FindOneofByName(PyDescriptorPool* self, PyObject* arg) {
+  Py_ssize_t name_size;
+  char* name;
+  if (PyString_AsStringAndSize(arg, &name, &name_size) < 0) {
+    return nullptr;
+  }
+
+  const OneofDescriptor* oneof_descriptor =
+      self->pool->FindOneofByName(StringParam(name, name_size));
+  if (oneof_descriptor == nullptr) {
+    return SetErrorFromCollector(self->error_collector, name, "oneof");
+  }
+
+
+  return PyOneofDescriptor_FromDescriptor(oneof_descriptor);
+}
+
+static PyObject* FindOneofByNameMethod(PyObject* self, PyObject* arg) {
+  return FindOneofByName(reinterpret_cast<PyDescriptorPool*>(self), arg);
+}
+
+static PyObject* FindServiceByName(PyObject* self, PyObject* arg) {
+  Py_ssize_t name_size;
+  char* name;
+  if (PyString_AsStringAndSize(arg, &name, &name_size) < 0) {
+    return nullptr;
+  }
+
+  const ServiceDescriptor* service_descriptor =
+      reinterpret_cast<PyDescriptorPool*>(self)->pool->FindServiceByName(
+          StringParam(name, name_size));
+  if (service_descriptor == nullptr) {
+    return SetErrorFromCollector(
+        reinterpret_cast<PyDescriptorPool*>(self)->error_collector, name,
+        "service");
+  }
+
+
+  return PyServiceDescriptor_FromDescriptor(service_descriptor);
+}
+
+static PyObject* FindMethodByName(PyObject* self, PyObject* arg) {
+  Py_ssize_t name_size;
+  char* name;
+  if (PyString_AsStringAndSize(arg, &name, &name_size) < 0) {
+    return nullptr;
+  }
+
+  const MethodDescriptor* method_descriptor =
+      reinterpret_cast<PyDescriptorPool*>(self)->pool->FindMethodByName(
+          StringParam(name, name_size));
+  if (method_descriptor == nullptr) {
+    return SetErrorFromCollector(
+        reinterpret_cast<PyDescriptorPool*>(self)->error_collector, name,
+        "method");
+  }
+
+
+  return PyMethodDescriptor_FromDescriptor(method_descriptor);
+}
+
+static PyObject* FindFileContainingSymbol(PyObject* self, PyObject* arg) {
+  Py_ssize_t name_size;
+  char* name;
+  if (PyString_AsStringAndSize(arg, &name, &name_size) < 0) {
+    return nullptr;
+  }
+
+  const FileDescriptor* file_descriptor =
+      reinterpret_cast<PyDescriptorPool*>(self)->pool->FindFileContainingSymbol(
+          StringParam(name, name_size));
+  if (file_descriptor == nullptr) {
+    return SetErrorFromCollector(
+        reinterpret_cast<PyDescriptorPool*>(self)->error_collector, name,
+        "symbol");
+  }
+
+
+  return PyFileDescriptor_FromDescriptor(file_descriptor);
+}
+
+static PyObject* FindExtensionByNumber(PyObject* self, PyObject* args) {
+  PyObject* message_descriptor;
+  int number;
+  if (!PyArg_ParseTuple(args, "Oi", &message_descriptor, &number)) {
+    return nullptr;
+  }
+  const Descriptor* descriptor = PyMessageDescriptor_AsDescriptor(
+      message_descriptor);
+  if (descriptor == nullptr) {
+    return nullptr;
+  }
+
+  const FieldDescriptor* extension_descriptor =
+      reinterpret_cast<PyDescriptorPool*>(self)->pool->FindExtensionByNumber(
+          descriptor, number);
+  if (extension_descriptor == nullptr) {
+    BuildFileErrorCollector* error_collector =
+        reinterpret_cast<BuildFileErrorCollector*>(
+            reinterpret_cast<PyDescriptorPool*>(self)->error_collector);
+    if (error_collector && !error_collector->error_message.empty()) {
+      PyErr_Format(PyExc_KeyError, "Couldn't build file for Extension %.d\n%s",
+                   number, error_collector->error_message.c_str());
+      error_collector->Clear();
+      return nullptr;
+    }
+    PyErr_Format(PyExc_KeyError, "Couldn't find Extension %d", number);
+    return nullptr;
+  }
+
+
+  return PyFieldDescriptor_FromDescriptor(extension_descriptor);
+}
+
+static PyObject* FindAllExtensions(PyObject* self, PyObject* arg) {
+  const Descriptor* descriptor = PyMessageDescriptor_AsDescriptor(arg);
+  if (descriptor == nullptr) {
+    return nullptr;
+  }
+
+  std::vector<const FieldDescriptor*> extensions;
+  reinterpret_cast<PyDescriptorPool*>(self)->pool->FindAllExtensions(
+      descriptor, &extensions);
+
+  ScopedPyObjectPtr result(PyList_New(extensions.size()));
+  if (result == nullptr) {
+    return nullptr;
+  }
+  for (int i = 0; i < extensions.size(); i++) {
+    PyObject* extension = PyFieldDescriptor_FromDescriptor(extensions[i]);
+    if (extension == nullptr) {
+      return nullptr;
+    }
+    PyList_SET_ITEM(result.get(), i, extension);  // Steals the reference.
+  }
+  return result.release();
+}
+
+// These functions should not exist -- the only valid way to create
+// descriptors is to call Add() or AddSerializedFile().
+// But these AddDescriptor() functions were created in Python and some people
+// call them, so we support them for now for compatibility.
+// However we do check that the existing descriptor already exists in the pool,
+// which appears to always be true for existing calls -- but then why do people
+// call a function that will just be a no-op?
+// TODO(amauryfa): Need to investigate further.
+
+static PyObject* AddFileDescriptor(PyObject* self, PyObject* descriptor) {
+  const FileDescriptor* file_descriptor =
+      PyFileDescriptor_AsDescriptor(descriptor);
+  if (!file_descriptor) {
+    return nullptr;
+  }
+  if (file_descriptor !=
+      reinterpret_cast<PyDescriptorPool*>(self)->pool->FindFileByName(
+          file_descriptor->name())) {
+    PyErr_Format(PyExc_ValueError,
+                 "The file descriptor %s does not belong to this pool",
+                 file_descriptor->name().c_str());
+    return nullptr;
+  }
+  Py_RETURN_NONE;
+}
+
+static PyObject* AddDescriptor(PyObject* self, PyObject* descriptor) {
+  const Descriptor* message_descriptor =
+      PyMessageDescriptor_AsDescriptor(descriptor);
+  if (!message_descriptor) {
+    return nullptr;
+  }
+  if (message_descriptor !=
+      reinterpret_cast<PyDescriptorPool*>(self)->pool->FindMessageTypeByName(
+          message_descriptor->full_name())) {
+    PyErr_Format(PyExc_ValueError,
+                 "The message descriptor %s does not belong to this pool",
+                 message_descriptor->full_name().c_str());
+    return nullptr;
+  }
+  Py_RETURN_NONE;
+}
+
+static PyObject* AddEnumDescriptor(PyObject* self, PyObject* descriptor) {
+  const EnumDescriptor* enum_descriptor =
+      PyEnumDescriptor_AsDescriptor(descriptor);
+  if (!enum_descriptor) {
+    return nullptr;
+  }
+  if (enum_descriptor !=
+      reinterpret_cast<PyDescriptorPool*>(self)->pool->FindEnumTypeByName(
+          enum_descriptor->full_name())) {
+    PyErr_Format(PyExc_ValueError,
+                 "The enum descriptor %s does not belong to this pool",
+                 enum_descriptor->full_name().c_str());
+    return nullptr;
+  }
+  Py_RETURN_NONE;
+}
+
+static PyObject* AddExtensionDescriptor(PyObject* self, PyObject* descriptor) {
+  const FieldDescriptor* extension_descriptor =
+      PyFieldDescriptor_AsDescriptor(descriptor);
+  if (!extension_descriptor) {
+    return nullptr;
+  }
+  if (extension_descriptor !=
+      reinterpret_cast<PyDescriptorPool*>(self)->pool->FindExtensionByName(
+          extension_descriptor->full_name())) {
+    PyErr_Format(PyExc_ValueError,
+                 "The extension descriptor %s does not belong to this pool",
+                 extension_descriptor->full_name().c_str());
+    return nullptr;
+  }
+  Py_RETURN_NONE;
+}
+
+static PyObject* AddServiceDescriptor(PyObject* self, PyObject* descriptor) {
+  const ServiceDescriptor* service_descriptor =
+      PyServiceDescriptor_AsDescriptor(descriptor);
+  if (!service_descriptor) {
+    return nullptr;
+  }
+  if (service_descriptor !=
+      reinterpret_cast<PyDescriptorPool*>(self)->pool->FindServiceByName(
+          service_descriptor->full_name())) {
+    PyErr_Format(PyExc_ValueError,
+                 "The service descriptor %s does not belong to this pool",
+                 service_descriptor->full_name().c_str());
+    return nullptr;
+  }
+  Py_RETURN_NONE;
+}
+
+// The code below loads new Descriptors from a serialized FileDescriptorProto.
+static PyObject* AddSerializedFile(PyObject* pself, PyObject* serialized_pb) {
+  PyDescriptorPool* self = reinterpret_cast<PyDescriptorPool*>(pself);
+  char* message_type;
+  Py_ssize_t message_len;
+
+  if (self->database != nullptr) {
+    PyErr_SetString(
+        PyExc_ValueError,
+        "Cannot call Add on a DescriptorPool that uses a DescriptorDatabase. "
+        "Add your file to the underlying database.");
+    return nullptr;
+  }
+  if (!self->is_mutable) {
+    PyErr_SetString(
+        PyExc_ValueError,
+        "This DescriptorPool is not mutable and cannot add new definitions.");
+    return nullptr;
+  }
+
+  if (PyBytes_AsStringAndSize(serialized_pb, &message_type, &message_len) < 0) {
+    return nullptr;
+  }
+
+  FileDescriptorProto file_proto;
+  if (!file_proto.ParseFromArray(message_type, message_len)) {
+    PyErr_SetString(PyExc_TypeError, "Couldn't parse file content!");
+    return nullptr;
+  }
+
+  // If the file was already part of a C++ library, all its descriptors are in
+  // the underlying pool.  No need to do anything else.
+  const FileDescriptor* generated_file = nullptr;
+  if (self->underlay) {
+    generated_file = self->underlay->FindFileByName(file_proto.name());
+  }
+  if (generated_file != nullptr) {
+    return PyFileDescriptor_FromDescriptorWithSerializedPb(
+        generated_file, serialized_pb);
+  }
+
+  BuildFileErrorCollector error_collector;
+  const FileDescriptor* descriptor =
+      // Pool is mutable, we can remove the "const".
+      const_cast<DescriptorPool*>(self->pool)
+          ->BuildFileCollectingErrors(file_proto, &error_collector);
+  if (descriptor == nullptr) {
+    PyErr_Format(PyExc_TypeError,
+                 "Couldn't build proto file into descriptor pool!\n%s",
+                 error_collector.error_message.c_str());
+    return nullptr;
+  }
+
+
+  return PyFileDescriptor_FromDescriptorWithSerializedPb(
+      descriptor, serialized_pb);
+}
+
+static PyObject* Add(PyObject* self, PyObject* file_descriptor_proto) {
+  ScopedPyObjectPtr serialized_pb(
+      PyObject_CallMethod(file_descriptor_proto, "SerializeToString", nullptr));
+  if (serialized_pb == nullptr) {
+    return nullptr;
+  }
+  return AddSerializedFile(self, serialized_pb.get());
+}
+
+static PyMethodDef Methods[] = {
+    {"Add", Add, METH_O,
+     "Adds the FileDescriptorProto and its types to this pool."},
+    {"AddSerializedFile", AddSerializedFile, METH_O,
+     "Adds a serialized FileDescriptorProto to this pool."},
+
+    // TODO(amauryfa): Understand why the Python implementation differs from
+    // this one, ask users to use another API and deprecate these functions.
+    {"AddFileDescriptor", AddFileDescriptor, METH_O,
+     "No-op. Add() must have been called before."},
+    {"AddDescriptor", AddDescriptor, METH_O,
+     "No-op. Add() must have been called before."},
+    {"AddEnumDescriptor", AddEnumDescriptor, METH_O,
+     "No-op. Add() must have been called before."},
+    {"AddExtensionDescriptor", AddExtensionDescriptor, METH_O,
+     "No-op. Add() must have been called before."},
+    {"AddServiceDescriptor", AddServiceDescriptor, METH_O,
+     "No-op. Add() must have been called before."},
+
+    {"FindFileByName", FindFileByName, METH_O,
+     "Searches for a file descriptor by its .proto name."},
+    {"FindMessageTypeByName", FindMessageByName, METH_O,
+     "Searches for a message descriptor by full name."},
+    {"FindFieldByName", FindFieldByNameMethod, METH_O,
+     "Searches for a field descriptor by full name."},
+    {"FindExtensionByName", FindExtensionByNameMethod, METH_O,
+     "Searches for extension descriptor by full name."},
+    {"FindEnumTypeByName", FindEnumTypeByNameMethod, METH_O,
+     "Searches for enum type descriptor by full name."},
+    {"FindOneofByName", FindOneofByNameMethod, METH_O,
+     "Searches for oneof descriptor by full name."},
+    {"FindServiceByName", FindServiceByName, METH_O,
+     "Searches for service descriptor by full name."},
+    {"FindMethodByName", FindMethodByName, METH_O,
+     "Searches for method descriptor by full name."},
+
+    {"FindFileContainingSymbol", FindFileContainingSymbol, METH_O,
+     "Gets the FileDescriptor containing the specified symbol."},
+    {"FindExtensionByNumber", FindExtensionByNumber, METH_VARARGS,
+     "Gets the extension descriptor for the given number."},
+    {"FindAllExtensions", FindAllExtensions, METH_O,
+     "Gets all known extensions of the given message descriptor."},
+    {nullptr},
+};
+
+}  // namespace cdescriptor_pool
+
+PyTypeObject PyDescriptorPool_Type = {
+    PyVarObject_HEAD_INIT(&PyType_Type, 0) FULL_MODULE_NAME
+    ".DescriptorPool",          // tp_name
+    sizeof(PyDescriptorPool),   // tp_basicsize
+    0,                          // tp_itemsize
+    cdescriptor_pool::Dealloc,  // tp_dealloc
+#if PY_VERSION_HEX < 0x03080000
+    nullptr,  // tp_print
+#else
+    0,  // tp_vectorcall_offset
+#endif
+    nullptr,                                  // tp_getattr
+    nullptr,                                  // tp_setattr
+    nullptr,                                  // tp_compare
+    nullptr,                                  // tp_repr
+    nullptr,                                  // tp_as_number
+    nullptr,                                  // tp_as_sequence
+    nullptr,                                  // tp_as_mapping
+    nullptr,                                  // tp_hash
+    nullptr,                                  // tp_call
+    nullptr,                                  // tp_str
+    nullptr,                                  // tp_getattro
+    nullptr,                                  // tp_setattro
+    nullptr,                                  // tp_as_buffer
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,  // tp_flags
+    "A Descriptor Pool",                      // tp_doc
+    cdescriptor_pool::GcTraverse,             // tp_traverse
+    cdescriptor_pool::GcClear,                // tp_clear
+    nullptr,                                  // tp_richcompare
+    0,                                        // tp_weaklistoffset
+    nullptr,                                  // tp_iter
+    nullptr,                                  // tp_iternext
+    cdescriptor_pool::Methods,                // tp_methods
+    nullptr,                                  // tp_members
+    nullptr,                                  // tp_getset
+    nullptr,                                  // tp_base
+    nullptr,                                  // tp_dict
+    nullptr,                                  // tp_descr_get
+    nullptr,                                  // tp_descr_set
+    0,                                        // tp_dictoffset
+    nullptr,                                  // tp_init
+    nullptr,                                  // tp_alloc
+    cdescriptor_pool::New,                    // tp_new
+    PyObject_GC_Del,                          // tp_free
+};
+
+// This is the DescriptorPool which contains all the definitions from the
+// generated _pb2.py modules.
+static PyDescriptorPool* python_generated_pool = nullptr;
+
+bool InitDescriptorPool() {
+  if (PyType_Ready(&PyDescriptorPool_Type) < 0)
+    return false;
+
+  // The Pool of messages declared in Python libraries.
+  // generated_pool() contains all messages already linked in C++ libraries, and
+  // is used as underlay.
+  descriptor_pool_map =
+      new std::unordered_map<const DescriptorPool*, PyDescriptorPool*>;
+  python_generated_pool = cdescriptor_pool::PyDescriptorPool_NewWithUnderlay(
+      DescriptorPool::generated_pool());
+  if (python_generated_pool == nullptr) {
+    delete descriptor_pool_map;
+    return false;
+  }
+
+  // Register this pool to be found for C++-generated descriptors.
+  descriptor_pool_map->insert(
+      std::make_pair(DescriptorPool::generated_pool(),
+                     python_generated_pool));
+
+  return true;
+}
+
+// The default DescriptorPool used everywhere in this module.
+// Today it's the python_generated_pool.
+// TODO(amauryfa): Remove all usages of this function: the pool should be
+// derived from the context.
+PyDescriptorPool* GetDefaultDescriptorPool() {
+  return python_generated_pool;
+}
+
+PyDescriptorPool* GetDescriptorPool_FromPool(const DescriptorPool* pool) {
+  // Fast path for standard descriptors.
+  if (pool == python_generated_pool->pool ||
+      pool == DescriptorPool::generated_pool()) {
+    return python_generated_pool;
+  }
+  std::unordered_map<const DescriptorPool*, PyDescriptorPool*>::iterator it =
+      descriptor_pool_map->find(pool);
+  if (it == descriptor_pool_map->end()) {
+    PyErr_SetString(PyExc_KeyError, "Unknown descriptor pool");
+    return nullptr;
+  }
+  return it->second;
+}
+
+PyObject* PyDescriptorPool_FromPool(const DescriptorPool* pool) {
+  PyDescriptorPool* existing_pool = GetDescriptorPool_FromPool(pool);
+  if (existing_pool != nullptr) {
+    Py_INCREF(existing_pool);
+    return reinterpret_cast<PyObject*>(existing_pool);
+  } else {
+    PyErr_Clear();
+  }
+
+  PyDescriptorPool* cpool = cdescriptor_pool::_CreateDescriptorPool();
+  if (cpool == nullptr) {
+    return nullptr;
+  }
+  cpool->pool = const_cast<DescriptorPool*>(pool);
+  cpool->is_owned = false;
+  cpool->is_mutable = false;
+  cpool->underlay = nullptr;
+
+  if (!descriptor_pool_map->insert(std::make_pair(cpool->pool, cpool)).second) {
+    // Should never happen -- We already checked the existence above.
+    PyErr_SetString(PyExc_ValueError, "DescriptorPool already registered");
+    return nullptr;
+  }
+
+  return reinterpret_cast<PyObject*>(cpool);
+}
+
+}  // namespace python
+}  // namespace protobuf
+}  // namespace google
diff --git a/lark_channel/ws/pb/google/protobuf/pyext/descriptor_pool.h b/lark_channel/ws/pb/google/protobuf/pyext/descriptor_pool.h
new file mode 100644
index 0000000..5d3c3a9
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/pyext/descriptor_pool.h
@@ -0,0 +1,149 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_PYTHON_CPP_DESCRIPTOR_POOL_H__
+#define GOOGLE_PROTOBUF_PYTHON_CPP_DESCRIPTOR_POOL_H__
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+#include <unordered_map>
+#include <google/protobuf/descriptor.h>
+
+namespace google {
+namespace protobuf {
+namespace python {
+
+struct PyMessageFactory;
+
+// The (meta) type of all Messages classes.
+struct CMessageClass;
+
+// Wraps operations to the global DescriptorPool which contains information
+// about all messages and fields.
+//
+// There is normally one pool per process. We make it a Python object only
+// because it contains many Python references.
+//
+// "Methods" that interacts with this DescriptorPool are in the cdescriptor_pool
+// namespace.
+typedef struct PyDescriptorPool {
+  PyObject_HEAD;
+
+  // The C++ pool containing Descriptors.
+  const DescriptorPool* pool;
+
+  // True if we should free the pointer above.
+  bool is_owned;
+
+  // True if this pool accepts new proto definitions.
+  // In this case it is allowed to const_cast<DescriptorPool*>(pool).
+  bool is_mutable;
+
+
+  // The error collector to store error info. Can be NULL. This pointer is
+  // owned.
+  DescriptorPool::ErrorCollector* error_collector;
+
+  // The C++ pool acting as an underlay. Can be NULL.
+  // This pointer is not owned and must stay alive.
+  const DescriptorPool* underlay;
+
+  // The C++ descriptor database used to fetch unknown protos. Can be NULL.
+  // This pointer is owned.
+  const DescriptorDatabase* database;
+
+  // The preferred MessageFactory to be used by descriptors.
+  // TODO(amauryfa): Don't create the Factory from the DescriptorPool, but
+  // use the one passed while creating message classes. And remove this member.
+  PyMessageFactory* py_message_factory;
+
+  // Cache the options for any kind of descriptor.
+  // Descriptor pointers are owned by the DescriptorPool above.
+  // Python objects are owned by the map.
+  std::unordered_map<const void*, PyObject*>* descriptor_options;
+} PyDescriptorPool;
+
+
+extern PyTypeObject PyDescriptorPool_Type;
+
+namespace cdescriptor_pool {
+
+
+// The functions below are also exposed as methods of the DescriptorPool type.
+
+// Looks up a field by name. Returns a PyFieldDescriptor corresponding to
+// the field on success, or NULL on failure.
+//
+// Returns a new reference.
+PyObject* FindFieldByName(PyDescriptorPool* self, PyObject* name);
+
+// Looks up an extension by name. Returns a PyFieldDescriptor corresponding
+// to the field on success, or NULL on failure.
+//
+// Returns a new reference.
+PyObject* FindExtensionByName(PyDescriptorPool* self, PyObject* arg);
+
+// Looks up an enum type by name. Returns a PyEnumDescriptor corresponding
+// to the field on success, or NULL on failure.
+//
+// Returns a new reference.
+PyObject* FindEnumTypeByName(PyDescriptorPool* self, PyObject* arg);
+
+// Looks up a oneof by name. Returns a COneofDescriptor corresponding
+// to the oneof on success, or NULL on failure.
+//
+// Returns a new reference.
+PyObject* FindOneofByName(PyDescriptorPool* self, PyObject* arg);
+
+}  // namespace cdescriptor_pool
+
+// Retrieves the global descriptor pool owned by the _message module.
+// This is the one used by pb2.py generated modules.
+// Returns a *borrowed* reference.
+// "Default" pool used to register messages from _pb2.py modules.
+PyDescriptorPool* GetDefaultDescriptorPool();
+
+// Retrieves an existing python descriptor pool owning the C++ descriptor pool.
+// Returns a *borrowed* reference.
+PyDescriptorPool* GetDescriptorPool_FromPool(const DescriptorPool* pool);
+
+// Wraps a C++ descriptor pool in a Python object, creates it if necessary.
+// Returns a new reference.
+PyObject* PyDescriptorPool_FromPool(const DescriptorPool* pool);
+
+// Initialize objects used by this module.
+bool InitDescriptorPool();
+
+}  // namespace python
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_PYTHON_CPP_DESCRIPTOR_POOL_H__
diff --git a/lark_channel/ws/pb/google/protobuf/pyext/extension_dict.cc b/lark_channel/ws/pb/google/protobuf/pyext/extension_dict.cc
new file mode 100644
index 0000000..692029f
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/pyext/extension_dict.cc
@@ -0,0 +1,484 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: anuraag@google.com (Anuraag Agrawal)
+// Author: tibell@google.com (Johan Tibell)
+
+#include <google/protobuf/pyext/extension_dict.h>
+
+#include <cstdint>
+#include <memory>
+
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/descriptor.pb.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/dynamic_message.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/pyext/descriptor.h>
+#include <google/protobuf/pyext/message.h>
+#include <google/protobuf/pyext/message_factory.h>
+#include <google/protobuf/pyext/repeated_composite_container.h>
+#include <google/protobuf/pyext/repeated_scalar_container.h>
+#include <google/protobuf/pyext/scoped_pyobject_ptr.h>
+
+#define PyString_AsStringAndSize(ob, charpp, sizep)              \
+  (PyUnicode_Check(ob)                                           \
+       ? ((*(charpp) = const_cast<char*>(                        \
+               PyUnicode_AsUTF8AndSize(ob, (sizep)))) == nullptr \
+              ? -1                                               \
+              : 0)                                               \
+       : PyBytes_AsStringAndSize(ob, (charpp), (sizep)))
+
+namespace google {
+namespace protobuf {
+namespace python {
+
+namespace extension_dict {
+
+static Py_ssize_t len(ExtensionDict* self) {
+  Py_ssize_t size = 0;
+  std::vector<const FieldDescriptor*> fields;
+  self->parent->message->GetReflection()->ListFields(*self->parent->message,
+                                                     &fields);
+
+  for (size_t i = 0; i < fields.size(); ++i) {
+    if (fields[i]->is_extension()) {
+      // With C++ descriptors, the field can always be retrieved, but for
+      // unknown extensions which have not been imported in Python code, there
+      // is no message class and we cannot retrieve the value.
+      // ListFields() has the same behavior.
+      if (fields[i]->message_type() != nullptr &&
+          message_factory::GetMessageClass(
+              cmessage::GetFactoryForMessage(self->parent),
+              fields[i]->message_type()) == nullptr) {
+        PyErr_Clear();
+        continue;
+      }
+      ++size;
+    }
+  }
+  return size;
+}
+
+struct ExtensionIterator {
+  PyObject_HEAD;
+  Py_ssize_t index;
+  std::vector<const FieldDescriptor*> fields;
+
+  // Owned reference, to keep the FieldDescriptors alive.
+  ExtensionDict* extension_dict;
+};
+
+PyObject* GetIter(PyObject* _self) {
+  ExtensionDict* self = reinterpret_cast<ExtensionDict*>(_self);
+
+  ScopedPyObjectPtr obj(PyType_GenericAlloc(&ExtensionIterator_Type, 0));
+  if (obj == nullptr) {
+    return PyErr_Format(PyExc_MemoryError,
+                        "Could not allocate extension iterator");
+  }
+
+  ExtensionIterator* iter = reinterpret_cast<ExtensionIterator*>(obj.get());
+
+  // Call "placement new" to initialize. So the constructor of
+  // std::vector<...> fields will be called.
+  new (iter) ExtensionIterator;
+
+  self->parent->message->GetReflection()->ListFields(*self->parent->message,
+                                                     &iter->fields);
+  iter->index = 0;
+  Py_INCREF(self);
+  iter->extension_dict = self;
+
+  return obj.release();
+}
+
+static void DeallocExtensionIterator(PyObject* _self) {
+  ExtensionIterator* self = reinterpret_cast<ExtensionIterator*>(_self);
+  self->fields.clear();
+  Py_XDECREF(self->extension_dict);
+  self->~ExtensionIterator();
+  Py_TYPE(_self)->tp_free(_self);
+}
+
+PyObject* subscript(ExtensionDict* self, PyObject* key) {
+  const FieldDescriptor* descriptor = cmessage::GetExtensionDescriptor(key);
+  if (descriptor == nullptr) {
+    return nullptr;
+  }
+  if (!CheckFieldBelongsToMessage(descriptor, self->parent->message)) {
+    return nullptr;
+  }
+
+  if (descriptor->label() != FieldDescriptor::LABEL_REPEATED &&
+      descriptor->cpp_type() != FieldDescriptor::CPPTYPE_MESSAGE) {
+    return cmessage::InternalGetScalar(self->parent->message, descriptor);
+  }
+
+  CMessage::CompositeFieldsMap::iterator iterator =
+      self->parent->composite_fields->find(descriptor);
+  if (iterator != self->parent->composite_fields->end()) {
+    Py_INCREF(iterator->second);
+    return iterator->second->AsPyObject();
+  }
+
+  if (descriptor->label() != FieldDescriptor::LABEL_REPEATED &&
+      descriptor->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
+    // TODO(plabatut): consider building the class on the fly!
+    ContainerBase* sub_message = cmessage::InternalGetSubMessage(
+        self->parent, descriptor);
+    if (sub_message == nullptr) {
+      return nullptr;
+    }
+    (*self->parent->composite_fields)[descriptor] = sub_message;
+    return sub_message->AsPyObject();
+  }
+
+  if (descriptor->label() == FieldDescriptor::LABEL_REPEATED) {
+    if (descriptor->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
+      // On the fly message class creation is needed to support the following
+      // situation:
+      // 1- add FileDescriptor to the pool that contains extensions of a message
+      //    defined by another proto file. Do not create any message classes.
+      // 2- instantiate an extended message, and access the extension using
+      //    the field descriptor.
+      // 3- the extension submessage fails to be returned, because no class has
+      //    been created.
+      // It happens when deserializing text proto format, or when enumerating
+      // fields of a deserialized message.
+      CMessageClass* message_class = message_factory::GetOrCreateMessageClass(
+          cmessage::GetFactoryForMessage(self->parent),
+          descriptor->message_type());
+      ScopedPyObjectPtr message_class_handler(
+        reinterpret_cast<PyObject*>(message_class));
+      if (message_class == nullptr) {
+        return nullptr;
+      }
+      ContainerBase* py_container = repeated_composite_container::NewContainer(
+          self->parent, descriptor, message_class);
+      if (py_container == nullptr) {
+        return nullptr;
+      }
+      (*self->parent->composite_fields)[descriptor] = py_container;
+      return py_container->AsPyObject();
+    } else {
+      ContainerBase* py_container = repeated_scalar_container::NewContainer(
+          self->parent, descriptor);
+      if (py_container == nullptr) {
+        return nullptr;
+      }
+      (*self->parent->composite_fields)[descriptor] = py_container;
+      return py_container->AsPyObject();
+    }
+  }
+  PyErr_SetString(PyExc_ValueError, "control reached unexpected line");
+  return nullptr;
+}
+
+int ass_subscript(ExtensionDict* self, PyObject* key, PyObject* value) {
+  const FieldDescriptor* descriptor = cmessage::GetExtensionDescriptor(key);
+  if (descriptor == nullptr) {
+    return -1;
+  }
+  if (!CheckFieldBelongsToMessage(descriptor, self->parent->message)) {
+    return -1;
+  }
+
+  if (value == nullptr) {
+    return cmessage::ClearFieldByDescriptor(self->parent, descriptor);
+  }
+
+  if (descriptor->label() != FieldDescriptor::LABEL_OPTIONAL ||
+      descriptor->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
+    PyErr_SetString(PyExc_TypeError, "Extension is repeated and/or composite "
+                    "type");
+    return -1;
+  }
+  cmessage::AssureWritable(self->parent);
+  if (cmessage::InternalSetScalar(self->parent, descriptor, value) < 0) {
+    return -1;
+  }
+  return 0;
+}
+
+PyObject* _FindExtensionByName(ExtensionDict* self, PyObject* arg) {
+  char* name;
+  Py_ssize_t name_size;
+  if (PyString_AsStringAndSize(arg, &name, &name_size) < 0) {
+    return nullptr;
+  }
+
+  PyDescriptorPool* pool = cmessage::GetFactoryForMessage(self->parent)->pool;
+  const FieldDescriptor* message_extension =
+      pool->pool->FindExtensionByName(StringParam(name, name_size));
+  if (message_extension == nullptr) {
+    // Is is the name of a message set extension?
+    const Descriptor* message_descriptor =
+        pool->pool->FindMessageTypeByName(StringParam(name, name_size));
+    if (message_descriptor && message_descriptor->extension_count() > 0) {
+      const FieldDescriptor* extension = message_descriptor->extension(0);
+      if (extension->is_extension() &&
+          extension->containing_type()->options().message_set_wire_format() &&
+          extension->type() == FieldDescriptor::TYPE_MESSAGE &&
+          extension->label() == FieldDescriptor::LABEL_OPTIONAL) {
+        message_extension = extension;
+      }
+    }
+  }
+  if (message_extension == nullptr) {
+    Py_RETURN_NONE;
+  }
+
+  return PyFieldDescriptor_FromDescriptor(message_extension);
+}
+
+PyObject* _FindExtensionByNumber(ExtensionDict* self, PyObject* arg) {
+  int64_t number = PyLong_AsLong(arg);
+  if (number == -1 && PyErr_Occurred()) {
+    return nullptr;
+  }
+
+  PyDescriptorPool* pool = cmessage::GetFactoryForMessage(self->parent)->pool;
+  const FieldDescriptor* message_extension = pool->pool->FindExtensionByNumber(
+      self->parent->message->GetDescriptor(), number);
+  if (message_extension == nullptr) {
+    Py_RETURN_NONE;
+  }
+
+  return PyFieldDescriptor_FromDescriptor(message_extension);
+}
+
+static int Contains(PyObject* _self, PyObject* key) {
+  ExtensionDict* self = reinterpret_cast<ExtensionDict*>(_self);
+  const FieldDescriptor* field_descriptor =
+      cmessage::GetExtensionDescriptor(key);
+  if (field_descriptor == nullptr) {
+    return -1;
+  }
+
+  if (!field_descriptor->is_extension()) {
+    PyErr_Format(PyExc_KeyError, "%s is not an extension",
+                 field_descriptor->full_name().c_str());
+    return -1;
+  }
+
+  const Message* message = self->parent->message;
+  const Reflection* reflection = message->GetReflection();
+  if (field_descriptor->is_repeated()) {
+    if (reflection->FieldSize(*message, field_descriptor) > 0) {
+      return 1;
+    }
+  } else {
+    if (reflection->HasField(*message, field_descriptor)) {
+      return 1;
+    }
+  }
+
+  return 0;
+}
+
+ExtensionDict* NewExtensionDict(CMessage *parent) {
+  ExtensionDict* self = reinterpret_cast<ExtensionDict*>(
+      PyType_GenericAlloc(&ExtensionDict_Type, 0));
+  if (self == nullptr) {
+    return nullptr;
+  }
+
+  Py_INCREF(parent);
+  self->parent = parent;
+  return self;
+}
+
+void dealloc(PyObject* pself) {
+  ExtensionDict* self = reinterpret_cast<ExtensionDict*>(pself);
+  Py_CLEAR(self->parent);
+  Py_TYPE(self)->tp_free(reinterpret_cast<PyObject*>(self));
+}
+
+static PyObject* RichCompare(ExtensionDict* self, PyObject* other, int opid) {
+  // Only equality comparisons are implemented.
+  if (opid != Py_EQ && opid != Py_NE) {
+    Py_INCREF(Py_NotImplemented);
+    return Py_NotImplemented;
+  }
+  bool equals = false;
+  if (PyObject_TypeCheck(other, &ExtensionDict_Type)) {
+    equals = self->parent == reinterpret_cast<ExtensionDict*>(other)->parent;;
+  }
+  if (equals ^ (opid == Py_EQ)) {
+    Py_RETURN_FALSE;
+  } else {
+    Py_RETURN_TRUE;
+  }
+}
+static PySequenceMethods SeqMethods = {
+    (lenfunc)len,          // sq_length
+    nullptr,               // sq_concat
+    nullptr,               // sq_repeat
+    nullptr,               // sq_item
+    nullptr,               // sq_slice
+    nullptr,               // sq_ass_item
+    nullptr,               // sq_ass_slice
+    (objobjproc)Contains,  // sq_contains
+};
+
+static PyMappingMethods MpMethods = {
+  (lenfunc)len,                /* mp_length */
+  (binaryfunc)subscript,       /* mp_subscript */
+  (objobjargproc)ass_subscript,/* mp_ass_subscript */
+};
+
+#define EDMETHOD(name, args, doc) { #name, (PyCFunction)name, args, doc }
+static PyMethodDef Methods[] = {
+    EDMETHOD(_FindExtensionByName, METH_O, "Finds an extension by name."),
+    EDMETHOD(_FindExtensionByNumber, METH_O,
+             "Finds an extension by field number."),
+    {nullptr, nullptr},
+};
+
+}  // namespace extension_dict
+
+PyTypeObject ExtensionDict_Type = {
+    PyVarObject_HEAD_INIT(&PyType_Type, 0)  //
+    FULL_MODULE_NAME ".ExtensionDict",      // tp_name
+    sizeof(ExtensionDict),                  // tp_basicsize
+    0,                                      //  tp_itemsize
+    (destructor)extension_dict::dealloc,    //  tp_dealloc
+#if PY_VERSION_HEX < 0x03080000
+    nullptr,  // tp_print
+#else
+    0,  // tp_vectorcall_offset
+#endif
+    nullptr,                                   //  tp_getattr
+    nullptr,                                   //  tp_setattr
+    nullptr,                                   //  tp_compare
+    nullptr,                                   //  tp_repr
+    nullptr,                                   //  tp_as_number
+    &extension_dict::SeqMethods,               //  tp_as_sequence
+    &extension_dict::MpMethods,                //  tp_as_mapping
+    PyObject_HashNotImplemented,               //  tp_hash
+    nullptr,                                   //  tp_call
+    nullptr,                                   //  tp_str
+    nullptr,                                   //  tp_getattro
+    nullptr,                                   //  tp_setattro
+    nullptr,                                   //  tp_as_buffer
+    Py_TPFLAGS_DEFAULT,                        //  tp_flags
+    "An extension dict",                       //  tp_doc
+    nullptr,                                   //  tp_traverse
+    nullptr,                                   //  tp_clear
+    (richcmpfunc)extension_dict::RichCompare,  //  tp_richcompare
+    0,                                         //  tp_weaklistoffset
+    extension_dict::GetIter,                   //  tp_iter
+    nullptr,                                   //  tp_iternext
+    extension_dict::Methods,                   //  tp_methods
+    nullptr,                                   //  tp_members
+    nullptr,                                   //  tp_getset
+    nullptr,                                   //  tp_base
+    nullptr,                                   //  tp_dict
+    nullptr,                                   //  tp_descr_get
+    nullptr,                                   //  tp_descr_set
+    0,                                         //  tp_dictoffset
+    nullptr,                                   //  tp_init
+};
+
+PyObject* IterNext(PyObject* _self) {
+  extension_dict::ExtensionIterator* self =
+      reinterpret_cast<extension_dict::ExtensionIterator*>(_self);
+  Py_ssize_t total_size = self->fields.size();
+  Py_ssize_t index = self->index;
+  while (self->index < total_size) {
+    index = self->index;
+    ++self->index;
+    if (self->fields[index]->is_extension()) {
+      // With C++ descriptors, the field can always be retrieved, but for
+      // unknown extensions which have not been imported in Python code, there
+      // is no message class and we cannot retrieve the value.
+      // ListFields() has the same behavior.
+      if (self->fields[index]->message_type() != nullptr &&
+          message_factory::GetMessageClass(
+              cmessage::GetFactoryForMessage(self->extension_dict->parent),
+              self->fields[index]->message_type()) == nullptr) {
+        PyErr_Clear();
+        continue;
+      }
+
+      return PyFieldDescriptor_FromDescriptor(self->fields[index]);
+    }
+  }
+
+  return nullptr;
+}
+
+PyTypeObject ExtensionIterator_Type = {
+    PyVarObject_HEAD_INIT(&PyType_Type, 0)      //
+    FULL_MODULE_NAME ".ExtensionIterator",      //  tp_name
+    sizeof(extension_dict::ExtensionIterator),  //  tp_basicsize
+    0,                                          //  tp_itemsize
+    extension_dict::DeallocExtensionIterator,   //  tp_dealloc
+#if PY_VERSION_HEX < 0x03080000
+    nullptr,  // tp_print
+#else
+    0,  // tp_vectorcall_offset
+#endif
+    nullptr,                  //  tp_getattr
+    nullptr,                  //  tp_setattr
+    nullptr,                  //  tp_compare
+    nullptr,                  //  tp_repr
+    nullptr,                  //  tp_as_number
+    nullptr,                  //  tp_as_sequence
+    nullptr,                  //  tp_as_mapping
+    nullptr,                  //  tp_hash
+    nullptr,                  //  tp_call
+    nullptr,                  //  tp_str
+    nullptr,                  //  tp_getattro
+    nullptr,                  //  tp_setattro
+    nullptr,                  //  tp_as_buffer
+    Py_TPFLAGS_DEFAULT,       //  tp_flags
+    "A scalar map iterator",  //  tp_doc
+    nullptr,                  //  tp_traverse
+    nullptr,                  //  tp_clear
+    nullptr,                  //  tp_richcompare
+    0,                        //  tp_weaklistoffset
+    PyObject_SelfIter,        //  tp_iter
+    IterNext,                 //  tp_iternext
+    nullptr,                  //  tp_methods
+    nullptr,                  //  tp_members
+    nullptr,                  //  tp_getset
+    nullptr,                  //  tp_base
+    nullptr,                  //  tp_dict
+    nullptr,                  //  tp_descr_get
+    nullptr,                  //  tp_descr_set
+    0,                        //  tp_dictoffset
+    nullptr,                  //  tp_init
+};
+}  // namespace python
+}  // namespace protobuf
+}  // namespace google
diff --git a/lark_channel/ws/pb/google/protobuf/pyext/extension_dict.h b/lark_channel/ws/pb/google/protobuf/pyext/extension_dict.h
new file mode 100644
index 0000000..a058194
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/pyext/extension_dict.h
@@ -0,0 +1,72 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: anuraag@google.com (Anuraag Agrawal)
+// Author: tibell@google.com (Johan Tibell)
+
+#ifndef GOOGLE_PROTOBUF_PYTHON_CPP_EXTENSION_DICT_H__
+#define GOOGLE_PROTOBUF_PYTHON_CPP_EXTENSION_DICT_H__
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+#include <memory>
+
+#include <google/protobuf/pyext/message.h>
+
+namespace google {
+namespace protobuf {
+
+class Message;
+class FieldDescriptor;
+
+namespace python {
+
+typedef struct ExtensionDict {
+  PyObject_HEAD;
+
+  // Strong, owned reference to the parent message. Never NULL.
+  CMessage* parent;
+} ExtensionDict;
+
+extern PyTypeObject ExtensionDict_Type;
+extern PyTypeObject ExtensionIterator_Type;
+
+namespace extension_dict {
+
+// Builds an Extensions dict for a specific message.
+ExtensionDict* NewExtensionDict(CMessage *parent);
+
+}  // namespace extension_dict
+}  // namespace python
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_PYTHON_CPP_EXTENSION_DICT_H__
diff --git a/lark_channel/ws/pb/google/protobuf/pyext/field.cc b/lark_channel/ws/pb/google/protobuf/pyext/field.cc
new file mode 100644
index 0000000..0d3b0b9
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/pyext/field.cc
@@ -0,0 +1,143 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include <google/protobuf/pyext/field.h>
+
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/pyext/descriptor.h>
+#include <google/protobuf/pyext/message.h>
+
+namespace google {
+namespace protobuf {
+namespace python {
+
+namespace field {
+
+static PyObject* Repr(PyMessageFieldProperty* self) {
+  return PyUnicode_FromFormat("<field property '%s'>",
+                              self->field_descriptor->full_name().c_str());
+}
+
+static PyObject* DescrGet(PyMessageFieldProperty* self, PyObject* obj,
+                          PyObject* type) {
+  if (obj == nullptr) {
+    Py_INCREF(self);
+    return reinterpret_cast<PyObject*>(self);
+  }
+  return cmessage::GetFieldValue(reinterpret_cast<CMessage*>(obj),
+                                 self->field_descriptor);
+}
+
+static int DescrSet(PyMessageFieldProperty* self, PyObject* obj,
+                    PyObject* value) {
+  if (value == nullptr) {
+    PyErr_SetString(PyExc_AttributeError, "Cannot delete field attribute");
+    return -1;
+  }
+  return cmessage::SetFieldValue(reinterpret_cast<CMessage*>(obj),
+                                 self->field_descriptor, value);
+}
+
+static PyObject* GetDescriptor(PyMessageFieldProperty* self, void* closure) {
+  return PyFieldDescriptor_FromDescriptor(self->field_descriptor);
+}
+
+static PyObject* GetDoc(PyMessageFieldProperty* self, void* closure) {
+  return PyUnicode_FromFormat("Field %s",
+                              self->field_descriptor->full_name().c_str());
+}
+
+static PyGetSetDef Getters[] = {
+    {"DESCRIPTOR", (getter)GetDescriptor, nullptr, "Field descriptor"},
+    {"__doc__", (getter)GetDoc, nullptr, nullptr},
+    {nullptr},
+};
+}  // namespace field
+
+static PyTypeObject _CFieldProperty_Type = {
+    PyVarObject_HEAD_INIT(&PyType_Type, 0)  // head
+    FULL_MODULE_NAME ".FieldProperty",      // tp_name
+    sizeof(PyMessageFieldProperty),         // tp_basicsize
+    0,                                      // tp_itemsize
+    nullptr,                                // tp_dealloc
+#if PY_VERSION_HEX < 0x03080000
+    nullptr,  // tp_print
+#else
+    0,  // tp_vectorcall_offset
+#endif
+    nullptr,                        // tp_getattr
+    nullptr,                        // tp_setattr
+    nullptr,                        // tp_compare
+    (reprfunc)field::Repr,          // tp_repr
+    nullptr,                        // tp_as_number
+    nullptr,                        // tp_as_sequence
+    nullptr,                        // tp_as_mapping
+    nullptr,                        // tp_hash
+    nullptr,                        // tp_call
+    nullptr,                        // tp_str
+    nullptr,                        // tp_getattro
+    nullptr,                        // tp_setattro
+    nullptr,                        // tp_as_buffer
+    Py_TPFLAGS_DEFAULT,             // tp_flags
+    "Field property of a Message",  // tp_doc
+    nullptr,                        // tp_traverse
+    nullptr,                        // tp_clear
+    nullptr,                        // tp_richcompare
+    0,                              // tp_weaklistoffset
+    nullptr,                        // tp_iter
+    nullptr,                        // tp_iternext
+    nullptr,                        // tp_methods
+    nullptr,                        // tp_members
+    field::Getters,                 // tp_getset
+    nullptr,                        // tp_base
+    nullptr,                        // tp_dict
+    (descrgetfunc)field::DescrGet,  // tp_descr_get
+    (descrsetfunc)field::DescrSet,  // tp_descr_set
+    0,                              // tp_dictoffset
+    nullptr,                        // tp_init
+    nullptr,                        // tp_alloc
+    nullptr,                        // tp_new
+};
+PyTypeObject* CFieldProperty_Type = &_CFieldProperty_Type;
+
+PyObject* NewFieldProperty(const FieldDescriptor* field_descriptor) {
+  // Create a new descriptor object
+  PyMessageFieldProperty* property =
+      PyObject_New(PyMessageFieldProperty, CFieldProperty_Type);
+  if (property == nullptr) {
+    return nullptr;
+  }
+  property->field_descriptor = field_descriptor;
+  return reinterpret_cast<PyObject*>(property);
+}
+
+}  // namespace python
+}  // namespace protobuf
+}  // namespace google
diff --git a/lark_channel/ws/pb/google/protobuf/pyext/field.h b/lark_channel/ws/pb/google/protobuf/pyext/field.h
new file mode 100644
index 0000000..f9f94c4
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/pyext/field.h
@@ -0,0 +1,60 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_PYTHON_CPP_FIELD_H__
+#define GOOGLE_PROTOBUF_PYTHON_CPP_FIELD_H__
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+namespace google {
+namespace protobuf {
+
+class FieldDescriptor;
+
+namespace python {
+
+// A data descriptor that represents a field in a Message class.
+struct PyMessageFieldProperty {
+  PyObject_HEAD;
+
+  // This pointer is owned by the same pool as the Message class it belongs to.
+  const FieldDescriptor* field_descriptor;
+};
+
+extern PyTypeObject* CFieldProperty_Type;
+
+PyObject* NewFieldProperty(const FieldDescriptor* field_descriptor);
+
+}  // namespace python
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_PYTHON_CPP_FIELD_H__
diff --git a/lark_channel/ws/pb/google/protobuf/pyext/map_container.cc b/lark_channel/ws/pb/google/protobuf/pyext/map_container.cc
new file mode 100644
index 0000000..4d516d2
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/pyext/map_container.cc
@@ -0,0 +1,931 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: haberman@google.com (Josh Haberman)
+
+#include <google/protobuf/pyext/map_container.h>
+
+#include <cstdint>
+#include <memory>
+
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/map.h>
+#include <google/protobuf/map_field.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/pyext/message.h>
+#include <google/protobuf/pyext/message_factory.h>
+#include <google/protobuf/pyext/repeated_composite_container.h>
+#include <google/protobuf/pyext/scoped_pyobject_ptr.h>
+#include <google/protobuf/stubs/map_util.h>
+
+namespace google {
+namespace protobuf {
+namespace python {
+
+// Functions that need access to map reflection functionality.
+// They need to be contained in this class because it is friended.
+class MapReflectionFriend {
+ public:
+  // Methods that are in common between the map types.
+  static PyObject* Contains(PyObject* _self, PyObject* key);
+  static Py_ssize_t Length(PyObject* _self);
+  static PyObject* GetIterator(PyObject *_self);
+  static PyObject* IterNext(PyObject* _self);
+  static PyObject* MergeFrom(PyObject* _self, PyObject* arg);
+
+  // Methods that differ between the map types.
+  static PyObject* ScalarMapGetItem(PyObject* _self, PyObject* key);
+  static PyObject* MessageMapGetItem(PyObject* _self, PyObject* key);
+  static int ScalarMapSetItem(PyObject* _self, PyObject* key, PyObject* v);
+  static int MessageMapSetItem(PyObject* _self, PyObject* key, PyObject* v);
+  static PyObject* ScalarMapToStr(PyObject* _self);
+  static PyObject* MessageMapToStr(PyObject* _self);
+};
+
+struct MapIterator {
+  PyObject_HEAD;
+
+  std::unique_ptr<::google::protobuf::MapIterator> iter;
+
+  // A pointer back to the container, so we can notice changes to the version.
+  // We own a ref on this.
+  MapContainer* container;
+
+  // We need to keep a ref on the parent Message too, because
+  // MapIterator::~MapIterator() accesses it.  Normally this would be ok because
+  // the ref on container (above) would guarantee outlive semantics.  However in
+  // the case of ClearField(), the MapContainer points to a different message,
+  // a copy of the original.  But our iterator still points to the original,
+  // which could now get deleted before us.
+  //
+  // To prevent this, we ensure that the Message will always stay alive as long
+  // as this iterator does.  This is solely for the benefit of the MapIterator
+  // destructor -- we should never actually access the iterator in this state
+  // except to delete it.
+  CMessage* parent;
+  // The version of the map when we took the iterator to it.
+  //
+  // We store this so that if the map is modified during iteration we can throw
+  // an error.
+  uint64_t version;
+};
+
+Message* MapContainer::GetMutableMessage() {
+  cmessage::AssureWritable(parent);
+  return parent->message;
+}
+
+// Consumes a reference on the Python string object.
+static bool PyStringToSTL(PyObject* py_string, std::string* stl_string) {
+  char *value;
+  Py_ssize_t value_len;
+
+  if (!py_string) {
+    return false;
+  }
+  if (PyBytes_AsStringAndSize(py_string, &value, &value_len) < 0) {
+    Py_DECREF(py_string);
+    return false;
+  } else {
+    stl_string->assign(value, value_len);
+    Py_DECREF(py_string);
+    return true;
+  }
+}
+
+static bool PythonToMapKey(MapContainer* self, PyObject* obj, MapKey* key) {
+  const FieldDescriptor* field_descriptor =
+      self->parent_field_descriptor->message_type()->map_key();
+  switch (field_descriptor->cpp_type()) {
+    case FieldDescriptor::CPPTYPE_INT32: {
+      GOOGLE_CHECK_GET_INT32(obj, value, false);
+      key->SetInt32Value(value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_INT64: {
+      GOOGLE_CHECK_GET_INT64(obj, value, false);
+      key->SetInt64Value(value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_UINT32: {
+      GOOGLE_CHECK_GET_UINT32(obj, value, false);
+      key->SetUInt32Value(value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_UINT64: {
+      GOOGLE_CHECK_GET_UINT64(obj, value, false);
+      key->SetUInt64Value(value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_BOOL: {
+      GOOGLE_CHECK_GET_BOOL(obj, value, false);
+      key->SetBoolValue(value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_STRING: {
+      std::string str;
+      if (!PyStringToSTL(CheckString(obj, field_descriptor), &str)) {
+        return false;
+      }
+      key->SetStringValue(str);
+      break;
+    }
+    default:
+      PyErr_Format(
+          PyExc_SystemError, "Type %d cannot be a map key",
+          field_descriptor->cpp_type());
+      return false;
+  }
+  return true;
+}
+
+static PyObject* MapKeyToPython(MapContainer* self, const MapKey& key) {
+  const FieldDescriptor* field_descriptor =
+      self->parent_field_descriptor->message_type()->map_key();
+  switch (field_descriptor->cpp_type()) {
+    case FieldDescriptor::CPPTYPE_INT32:
+      return PyLong_FromLong(key.GetInt32Value());
+    case FieldDescriptor::CPPTYPE_INT64:
+      return PyLong_FromLongLong(key.GetInt64Value());
+    case FieldDescriptor::CPPTYPE_UINT32:
+      return PyLong_FromSize_t(key.GetUInt32Value());
+    case FieldDescriptor::CPPTYPE_UINT64:
+      return PyLong_FromUnsignedLongLong(key.GetUInt64Value());
+    case FieldDescriptor::CPPTYPE_BOOL:
+      return PyBool_FromLong(key.GetBoolValue());
+    case FieldDescriptor::CPPTYPE_STRING:
+      return ToStringObject(field_descriptor, key.GetStringValue());
+    default:
+      PyErr_Format(
+          PyExc_SystemError, "Couldn't convert type %d to value",
+          field_descriptor->cpp_type());
+      return nullptr;
+  }
+}
+
+// This is only used for ScalarMap, so we don't need to handle the
+// CPPTYPE_MESSAGE case.
+PyObject* MapValueRefToPython(MapContainer* self, const MapValueRef& value) {
+  const FieldDescriptor* field_descriptor =
+      self->parent_field_descriptor->message_type()->map_value();
+  switch (field_descriptor->cpp_type()) {
+    case FieldDescriptor::CPPTYPE_INT32:
+      return PyLong_FromLong(value.GetInt32Value());
+    case FieldDescriptor::CPPTYPE_INT64:
+      return PyLong_FromLongLong(value.GetInt64Value());
+    case FieldDescriptor::CPPTYPE_UINT32:
+      return PyLong_FromSize_t(value.GetUInt32Value());
+    case FieldDescriptor::CPPTYPE_UINT64:
+      return PyLong_FromUnsignedLongLong(value.GetUInt64Value());
+    case FieldDescriptor::CPPTYPE_FLOAT:
+      return PyFloat_FromDouble(value.GetFloatValue());
+    case FieldDescriptor::CPPTYPE_DOUBLE:
+      return PyFloat_FromDouble(value.GetDoubleValue());
+    case FieldDescriptor::CPPTYPE_BOOL:
+      return PyBool_FromLong(value.GetBoolValue());
+    case FieldDescriptor::CPPTYPE_STRING:
+      return ToStringObject(field_descriptor, value.GetStringValue());
+    case FieldDescriptor::CPPTYPE_ENUM:
+      return PyLong_FromLong(value.GetEnumValue());
+    default:
+      PyErr_Format(
+          PyExc_SystemError, "Couldn't convert type %d to value",
+          field_descriptor->cpp_type());
+      return nullptr;
+  }
+}
+
+// This is only used for ScalarMap, so we don't need to handle the
+// CPPTYPE_MESSAGE case.
+static bool PythonToMapValueRef(MapContainer* self, PyObject* obj,
+                                bool allow_unknown_enum_values,
+                                MapValueRef* value_ref) {
+  const FieldDescriptor* field_descriptor =
+      self->parent_field_descriptor->message_type()->map_value();
+  switch (field_descriptor->cpp_type()) {
+    case FieldDescriptor::CPPTYPE_INT32: {
+      GOOGLE_CHECK_GET_INT32(obj, value, false);
+      value_ref->SetInt32Value(value);
+      return true;
+    }
+    case FieldDescriptor::CPPTYPE_INT64: {
+      GOOGLE_CHECK_GET_INT64(obj, value, false);
+      value_ref->SetInt64Value(value);
+      return true;
+    }
+    case FieldDescriptor::CPPTYPE_UINT32: {
+      GOOGLE_CHECK_GET_UINT32(obj, value, false);
+      value_ref->SetUInt32Value(value);
+      return true;
+    }
+    case FieldDescriptor::CPPTYPE_UINT64: {
+      GOOGLE_CHECK_GET_UINT64(obj, value, false);
+      value_ref->SetUInt64Value(value);
+      return true;
+    }
+    case FieldDescriptor::CPPTYPE_FLOAT: {
+      GOOGLE_CHECK_GET_FLOAT(obj, value, false);
+      value_ref->SetFloatValue(value);
+      return true;
+    }
+    case FieldDescriptor::CPPTYPE_DOUBLE: {
+      GOOGLE_CHECK_GET_DOUBLE(obj, value, false);
+      value_ref->SetDoubleValue(value);
+      return true;
+    }
+    case FieldDescriptor::CPPTYPE_BOOL: {
+      GOOGLE_CHECK_GET_BOOL(obj, value, false);
+      value_ref->SetBoolValue(value);
+      return true;;
+    }
+    case FieldDescriptor::CPPTYPE_STRING: {
+      std::string str;
+      if (!PyStringToSTL(CheckString(obj, field_descriptor), &str)) {
+        return false;
+      }
+      value_ref->SetStringValue(str);
+      return true;
+    }
+    case FieldDescriptor::CPPTYPE_ENUM: {
+      GOOGLE_CHECK_GET_INT32(obj, value, false);
+      if (allow_unknown_enum_values) {
+        value_ref->SetEnumValue(value);
+        return true;
+      } else {
+        const EnumDescriptor* enum_descriptor = field_descriptor->enum_type();
+        const EnumValueDescriptor* enum_value =
+            enum_descriptor->FindValueByNumber(value);
+        if (enum_value != nullptr) {
+          value_ref->SetEnumValue(value);
+          return true;
+        } else {
+          PyErr_Format(PyExc_ValueError, "Unknown enum value: %d", value);
+          return false;
+        }
+      }
+      break;
+    }
+    default:
+      PyErr_Format(
+          PyExc_SystemError, "Setting value to a field of unknown type %d",
+          field_descriptor->cpp_type());
+      return false;
+  }
+}
+
+// Map methods common to ScalarMap and MessageMap //////////////////////////////
+
+static MapContainer* GetMap(PyObject* obj) {
+  return reinterpret_cast<MapContainer*>(obj);
+}
+
+Py_ssize_t MapReflectionFriend::Length(PyObject* _self) {
+  MapContainer* self = GetMap(_self);
+  const google::protobuf::Message* message = self->parent->message;
+  return message->GetReflection()->MapSize(*message,
+                                           self->parent_field_descriptor);
+}
+
+PyObject* Clear(PyObject* _self) {
+  MapContainer* self = GetMap(_self);
+  Message* message = self->GetMutableMessage();
+  const Reflection* reflection = message->GetReflection();
+
+  reflection->ClearField(message, self->parent_field_descriptor);
+
+  Py_RETURN_NONE;
+}
+
+PyObject* GetEntryClass(PyObject* _self) {
+  MapContainer* self = GetMap(_self);
+  CMessageClass* message_class = message_factory::GetMessageClass(
+      cmessage::GetFactoryForMessage(self->parent),
+      self->parent_field_descriptor->message_type());
+  Py_XINCREF(message_class);
+  return reinterpret_cast<PyObject*>(message_class);
+}
+
+PyObject* MapReflectionFriend::MergeFrom(PyObject* _self, PyObject* arg) {
+  MapContainer* self = GetMap(_self);
+  if (!PyObject_TypeCheck(arg, ScalarMapContainer_Type) &&
+      !PyObject_TypeCheck(arg, MessageMapContainer_Type)) {
+    PyErr_SetString(PyExc_AttributeError, "Not a map field");
+    return nullptr;
+  }
+  MapContainer* other_map = GetMap(arg);
+  Message* message = self->GetMutableMessage();
+  const Message* other_message = other_map->parent->message;
+  const Reflection* reflection = message->GetReflection();
+  const Reflection* other_reflection = other_message->GetReflection();
+  internal::MapFieldBase* field = reflection->MutableMapData(
+      message, self->parent_field_descriptor);
+  const internal::MapFieldBase* other_field = other_reflection->GetMapData(
+      *other_message, other_map->parent_field_descriptor);
+  field->MergeFrom(*other_field);
+  self->version++;
+  Py_RETURN_NONE;
+}
+
+PyObject* MapReflectionFriend::Contains(PyObject* _self, PyObject* key) {
+  MapContainer* self = GetMap(_self);
+
+  const Message* message = self->parent->message;
+  const Reflection* reflection = message->GetReflection();
+  MapKey map_key;
+
+  if (!PythonToMapKey(self, key, &map_key)) {
+    return nullptr;
+  }
+
+  if (reflection->ContainsMapKey(*message, self->parent_field_descriptor,
+                                 map_key)) {
+    Py_RETURN_TRUE;
+  } else {
+    Py_RETURN_FALSE;
+  }
+}
+
+// ScalarMap ///////////////////////////////////////////////////////////////////
+
+MapContainer* NewScalarMapContainer(
+    CMessage* parent, const google::protobuf::FieldDescriptor* parent_field_descriptor) {
+  if (!CheckFieldBelongsToMessage(parent_field_descriptor, parent->message)) {
+    return nullptr;
+  }
+
+  PyObject* obj(PyType_GenericAlloc(ScalarMapContainer_Type, 0));
+  if (obj == nullptr) {
+    PyErr_Format(PyExc_RuntimeError,
+                 "Could not allocate new container.");
+    return nullptr;
+  }
+
+  MapContainer* self = GetMap(obj);
+
+  Py_INCREF(parent);
+  self->parent = parent;
+  self->parent_field_descriptor = parent_field_descriptor;
+  self->version = 0;
+
+  return self;
+}
+
+PyObject* MapReflectionFriend::ScalarMapGetItem(PyObject* _self,
+                                                PyObject* key) {
+  MapContainer* self = GetMap(_self);
+
+  Message* message = self->GetMutableMessage();
+  const Reflection* reflection = message->GetReflection();
+  MapKey map_key;
+  MapValueRef value;
+
+  if (!PythonToMapKey(self, key, &map_key)) {
+    return nullptr;
+  }
+
+  if (reflection->InsertOrLookupMapValue(message, self->parent_field_descriptor,
+                                         map_key, &value)) {
+    self->version++;
+  }
+
+  return MapValueRefToPython(self, value);
+}
+
+int MapReflectionFriend::ScalarMapSetItem(PyObject* _self, PyObject* key,
+                                          PyObject* v) {
+  MapContainer* self = GetMap(_self);
+
+  Message* message = self->GetMutableMessage();
+  const Reflection* reflection = message->GetReflection();
+  MapKey map_key;
+  MapValueRef value;
+
+  if (!PythonToMapKey(self, key, &map_key)) {
+    return -1;
+  }
+
+  if (v) {
+    // Set item to v.
+    if (reflection->InsertOrLookupMapValue(
+            message, self->parent_field_descriptor, map_key, &value)) {
+      self->version++;
+    }
+
+    if (!PythonToMapValueRef(self, v, reflection->SupportsUnknownEnumValues(),
+                             &value)) {
+      return -1;
+    }
+    return 0;
+  } else {
+    // Delete key from map.
+    if (reflection->DeleteMapValue(message, self->parent_field_descriptor,
+                                   map_key)) {
+      self->version++;
+      return 0;
+    } else {
+      PyErr_Format(PyExc_KeyError, "Key not present in map");
+      return -1;
+    }
+  }
+}
+
+static PyObject* ScalarMapGet(PyObject* self, PyObject* args,
+                              PyObject* kwargs) {
+  static const char* kwlist[] = {"key", "default", nullptr};
+  PyObject* key;
+  PyObject* default_value = nullptr;
+  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O",
+                                   const_cast<char**>(kwlist), &key,
+                                   &default_value)) {
+    return nullptr;
+  }
+
+  ScopedPyObjectPtr is_present(MapReflectionFriend::Contains(self, key));
+  if (is_present.get() == nullptr) {
+    return nullptr;
+  }
+
+  if (PyObject_IsTrue(is_present.get())) {
+    return MapReflectionFriend::ScalarMapGetItem(self, key);
+  } else {
+    if (default_value != nullptr) {
+      Py_INCREF(default_value);
+      return default_value;
+    } else {
+      Py_RETURN_NONE;
+    }
+  }
+}
+
+PyObject* MapReflectionFriend::ScalarMapToStr(PyObject* _self) {
+  ScopedPyObjectPtr dict(PyDict_New());
+  if (dict == nullptr) {
+    return nullptr;
+  }
+  ScopedPyObjectPtr key;
+  ScopedPyObjectPtr value;
+
+  MapContainer* self = GetMap(_self);
+  Message* message = self->GetMutableMessage();
+  const Reflection* reflection = message->GetReflection();
+  for (google::protobuf::MapIterator it = reflection->MapBegin(
+           message, self->parent_field_descriptor);
+       it != reflection->MapEnd(message, self->parent_field_descriptor);
+       ++it) {
+    key.reset(MapKeyToPython(self, it.GetKey()));
+    if (key == nullptr) {
+      return nullptr;
+    }
+    value.reset(MapValueRefToPython(self, it.GetValueRef()));
+    if (value == nullptr) {
+      return nullptr;
+    }
+    if (PyDict_SetItem(dict.get(), key.get(), value.get()) < 0) {
+      return nullptr;
+    }
+  }
+  return PyObject_Repr(dict.get());
+}
+
+static void ScalarMapDealloc(PyObject* _self) {
+  MapContainer* self = GetMap(_self);
+  self->RemoveFromParentCache();
+  PyTypeObject *type = Py_TYPE(_self);
+  type->tp_free(_self);
+  if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) {
+    // With Python3, the Map class is not static, and must be managed.
+    Py_DECREF(type);
+  }
+}
+
+static PyMethodDef ScalarMapMethods[] = {
+    {"__contains__", MapReflectionFriend::Contains, METH_O,
+     "Tests whether a key is a member of the map."},
+    {"clear", (PyCFunction)Clear, METH_NOARGS,
+     "Removes all elements from the map."},
+    {"get", (PyCFunction)ScalarMapGet, METH_VARARGS | METH_KEYWORDS,
+     "Gets the value for the given key if present, or otherwise a default"},
+    {"GetEntryClass", (PyCFunction)GetEntryClass, METH_NOARGS,
+     "Return the class used to build Entries of (key, value) pairs."},
+    {"MergeFrom", (PyCFunction)MapReflectionFriend::MergeFrom, METH_O,
+     "Merges a map into the current map."},
+    /*
+    { "__deepcopy__", (PyCFunction)DeepCopy, METH_VARARGS,
+      "Makes a deep copy of the class." },
+    { "__reduce__", (PyCFunction)Reduce, METH_NOARGS,
+      "Outputs picklable representation of the repeated field." },
+    */
+    {nullptr, nullptr},
+};
+
+PyTypeObject* ScalarMapContainer_Type;
+static PyType_Slot ScalarMapContainer_Type_slots[] = {
+    {Py_tp_dealloc, (void*)ScalarMapDealloc},
+    {Py_mp_length, (void*)MapReflectionFriend::Length},
+    {Py_mp_subscript, (void*)MapReflectionFriend::ScalarMapGetItem},
+    {Py_mp_ass_subscript, (void*)MapReflectionFriend::ScalarMapSetItem},
+    {Py_tp_methods, (void*)ScalarMapMethods},
+    {Py_tp_iter, (void*)MapReflectionFriend::GetIterator},
+    {Py_tp_repr, (void*)MapReflectionFriend::ScalarMapToStr},
+    {0, nullptr},
+};
+
+PyType_Spec ScalarMapContainer_Type_spec = {
+    FULL_MODULE_NAME ".ScalarMapContainer", sizeof(MapContainer), 0,
+    Py_TPFLAGS_DEFAULT, ScalarMapContainer_Type_slots};
+
+// MessageMap //////////////////////////////////////////////////////////////////
+
+static MessageMapContainer* GetMessageMap(PyObject* obj) {
+  return reinterpret_cast<MessageMapContainer*>(obj);
+}
+
+static PyObject* GetCMessage(MessageMapContainer* self, Message* message) {
+  // Get or create the CMessage object corresponding to this message.
+  return self->parent
+      ->BuildSubMessageFromPointer(self->parent_field_descriptor, message,
+                                   self->message_class)
+      ->AsPyObject();
+}
+
+MessageMapContainer* NewMessageMapContainer(
+    CMessage* parent, const google::protobuf::FieldDescriptor* parent_field_descriptor,
+    CMessageClass* message_class) {
+  if (!CheckFieldBelongsToMessage(parent_field_descriptor, parent->message)) {
+    return nullptr;
+  }
+
+  PyObject* obj = PyType_GenericAlloc(MessageMapContainer_Type, 0);
+  if (obj == nullptr) {
+    PyErr_SetString(PyExc_RuntimeError, "Could not allocate new container.");
+    return nullptr;
+  }
+
+  MessageMapContainer* self = GetMessageMap(obj);
+
+  Py_INCREF(parent);
+  self->parent = parent;
+  self->parent_field_descriptor = parent_field_descriptor;
+  self->version = 0;
+
+  Py_INCREF(message_class);
+  self->message_class = message_class;
+
+  return self;
+}
+
+int MapReflectionFriend::MessageMapSetItem(PyObject* _self, PyObject* key,
+                                           PyObject* v) {
+  if (v) {
+    PyErr_Format(PyExc_ValueError,
+                 "Direct assignment of submessage not allowed");
+    return -1;
+  }
+
+  // Now we know that this is a delete, not a set.
+
+  MessageMapContainer* self = GetMessageMap(_self);
+  Message* message = self->GetMutableMessage();
+  const Reflection* reflection = message->GetReflection();
+  MapKey map_key;
+  MapValueRef value;
+
+  self->version++;
+
+  if (!PythonToMapKey(self, key, &map_key)) {
+    return -1;
+  }
+
+  // Delete key from map.
+  if (reflection->ContainsMapKey(*message, self->parent_field_descriptor,
+                                 map_key)) {
+    // Delete key from CMessage dict.
+    MapValueRef value;
+    reflection->InsertOrLookupMapValue(message, self->parent_field_descriptor,
+                                       map_key, &value);
+    Message* sub_message = value.MutableMessageValue();
+    // If there is a living weak reference to an item, we "Release" it,
+    // otherwise we just discard the C++ value.
+    if (CMessage* released =
+            self->parent->MaybeReleaseSubMessage(sub_message)) {
+      Message* msg = released->message;
+      released->message = msg->New();
+      msg->GetReflection()->Swap(msg, released->message);
+    }
+
+    // Delete key from map.
+    reflection->DeleteMapValue(message, self->parent_field_descriptor,
+                               map_key);
+    return 0;
+  } else {
+    PyErr_Format(PyExc_KeyError, "Key not present in map");
+    return -1;
+  }
+}
+
+PyObject* MapReflectionFriend::MessageMapGetItem(PyObject* _self,
+                                                 PyObject* key) {
+  MessageMapContainer* self = GetMessageMap(_self);
+
+  Message* message = self->GetMutableMessage();
+  const Reflection* reflection = message->GetReflection();
+  MapKey map_key;
+  MapValueRef value;
+
+  if (!PythonToMapKey(self, key, &map_key)) {
+    return nullptr;
+  }
+
+  if (reflection->InsertOrLookupMapValue(message, self->parent_field_descriptor,
+                                         map_key, &value)) {
+    self->version++;
+  }
+
+  return GetCMessage(self, value.MutableMessageValue());
+}
+
+PyObject* MapReflectionFriend::MessageMapToStr(PyObject* _self) {
+  ScopedPyObjectPtr dict(PyDict_New());
+  if (dict == nullptr) {
+    return nullptr;
+  }
+  ScopedPyObjectPtr key;
+  ScopedPyObjectPtr value;
+
+  MessageMapContainer* self = GetMessageMap(_self);
+  Message* message = self->GetMutableMessage();
+  const Reflection* reflection = message->GetReflection();
+  for (google::protobuf::MapIterator it = reflection->MapBegin(
+           message, self->parent_field_descriptor);
+       it != reflection->MapEnd(message, self->parent_field_descriptor);
+       ++it) {
+    key.reset(MapKeyToPython(self, it.GetKey()));
+    if (key == nullptr) {
+      return nullptr;
+    }
+    value.reset(GetCMessage(self, it.MutableValueRef()->MutableMessageValue()));
+    if (value == nullptr) {
+      return nullptr;
+    }
+    if (PyDict_SetItem(dict.get(), key.get(), value.get()) < 0) {
+      return nullptr;
+    }
+  }
+  return PyObject_Repr(dict.get());
+}
+
+PyObject* MessageMapGet(PyObject* self, PyObject* args, PyObject* kwargs) {
+  static const char* kwlist[] = {"key", "default", nullptr};
+  PyObject* key;
+  PyObject* default_value = nullptr;
+  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O",
+                                   const_cast<char**>(kwlist), &key,
+                                   &default_value)) {
+    return nullptr;
+  }
+
+  ScopedPyObjectPtr is_present(MapReflectionFriend::Contains(self, key));
+  if (is_present.get() == nullptr) {
+    return nullptr;
+  }
+
+  if (PyObject_IsTrue(is_present.get())) {
+    return MapReflectionFriend::MessageMapGetItem(self, key);
+  } else {
+    if (default_value != nullptr) {
+      Py_INCREF(default_value);
+      return default_value;
+    } else {
+      Py_RETURN_NONE;
+    }
+  }
+}
+
+static void MessageMapDealloc(PyObject* _self) {
+  MessageMapContainer* self = GetMessageMap(_self);
+  self->RemoveFromParentCache();
+  Py_DECREF(self->message_class);
+  PyTypeObject *type = Py_TYPE(_self);
+  type->tp_free(_self);
+  if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) {
+    // With Python3, the Map class is not static, and must be managed.
+    Py_DECREF(type);
+  }
+}
+
+static PyMethodDef MessageMapMethods[] = {
+    {"__contains__", (PyCFunction)MapReflectionFriend::Contains, METH_O,
+     "Tests whether the map contains this element."},
+    {"clear", (PyCFunction)Clear, METH_NOARGS,
+     "Removes all elements from the map."},
+    {"get", (PyCFunction)MessageMapGet, METH_VARARGS | METH_KEYWORDS,
+     "Gets the value for the given key if present, or otherwise a default"},
+    {"get_or_create", MapReflectionFriend::MessageMapGetItem, METH_O,
+     "Alias for getitem, useful to make explicit that the map is mutated."},
+    {"GetEntryClass", (PyCFunction)GetEntryClass, METH_NOARGS,
+     "Return the class used to build Entries of (key, value) pairs."},
+    {"MergeFrom", (PyCFunction)MapReflectionFriend::MergeFrom, METH_O,
+     "Merges a map into the current map."},
+    /*
+    { "__deepcopy__", (PyCFunction)DeepCopy, METH_VARARGS,
+      "Makes a deep copy of the class." },
+    { "__reduce__", (PyCFunction)Reduce, METH_NOARGS,
+      "Outputs picklable representation of the repeated field." },
+    */
+    {nullptr, nullptr},
+};
+
+PyTypeObject* MessageMapContainer_Type;
+static PyType_Slot MessageMapContainer_Type_slots[] = {
+    {Py_tp_dealloc, (void*)MessageMapDealloc},
+    {Py_mp_length, (void*)MapReflectionFriend::Length},
+    {Py_mp_subscript, (void*)MapReflectionFriend::MessageMapGetItem},
+    {Py_mp_ass_subscript, (void*)MapReflectionFriend::MessageMapSetItem},
+    {Py_tp_methods, (void*)MessageMapMethods},
+    {Py_tp_iter, (void*)MapReflectionFriend::GetIterator},
+    {Py_tp_repr, (void*)MapReflectionFriend::MessageMapToStr},
+    {0, nullptr}};
+
+PyType_Spec MessageMapContainer_Type_spec = {
+    FULL_MODULE_NAME ".MessageMapContainer", sizeof(MessageMapContainer), 0,
+    Py_TPFLAGS_DEFAULT, MessageMapContainer_Type_slots};
+
+// MapIterator /////////////////////////////////////////////////////////////////
+
+static MapIterator* GetIter(PyObject* obj) {
+  return reinterpret_cast<MapIterator*>(obj);
+}
+
+PyObject* MapReflectionFriend::GetIterator(PyObject *_self) {
+  MapContainer* self = GetMap(_self);
+
+  ScopedPyObjectPtr obj(PyType_GenericAlloc(&MapIterator_Type, 0));
+  if (obj == nullptr) {
+    return PyErr_Format(PyExc_KeyError, "Could not allocate iterator");
+  }
+
+  MapIterator* iter = GetIter(obj.get());
+
+  Py_INCREF(self);
+  iter->container = self;
+  iter->version = self->version;
+  Py_INCREF(self->parent);
+  iter->parent = self->parent;
+
+  if (MapReflectionFriend::Length(_self) > 0) {
+    Message* message = self->GetMutableMessage();
+    const Reflection* reflection = message->GetReflection();
+
+    iter->iter.reset(new ::google::protobuf::MapIterator(
+        reflection->MapBegin(message, self->parent_field_descriptor)));
+  }
+
+  return obj.release();
+}
+
+PyObject* MapReflectionFriend::IterNext(PyObject* _self) {
+  MapIterator* self = GetIter(_self);
+
+  // This won't catch mutations to the map performed by MergeFrom(); no easy way
+  // to address that.
+  if (self->version != self->container->version) {
+    return PyErr_Format(PyExc_RuntimeError,
+                        "Map modified during iteration.");
+  }
+  if (self->parent != self->container->parent) {
+    return PyErr_Format(PyExc_RuntimeError,
+                        "Map cleared during iteration.");
+  }
+
+  if (self->iter.get() == nullptr) {
+    return nullptr;
+  }
+
+  Message* message = self->container->GetMutableMessage();
+  const Reflection* reflection = message->GetReflection();
+
+  if (*self->iter ==
+      reflection->MapEnd(message, self->container->parent_field_descriptor)) {
+    return nullptr;
+  }
+
+  PyObject* ret = MapKeyToPython(self->container, self->iter->GetKey());
+
+  ++(*self->iter);
+
+  return ret;
+}
+
+static void DeallocMapIterator(PyObject* _self) {
+  MapIterator* self = GetIter(_self);
+  self->iter.reset();
+  Py_CLEAR(self->container);
+  Py_CLEAR(self->parent);
+  Py_TYPE(_self)->tp_free(_self);
+}
+
+PyTypeObject MapIterator_Type = {
+    PyVarObject_HEAD_INIT(&PyType_Type, 0) FULL_MODULE_NAME
+    ".MapIterator",       //  tp_name
+    sizeof(MapIterator),  //  tp_basicsize
+    0,                    //  tp_itemsize
+    DeallocMapIterator,   //  tp_dealloc
+#if PY_VERSION_HEX < 0x03080000
+    nullptr,  // tp_print
+#else
+    0,  // tp_vectorcall_offset
+#endif
+    nullptr,                        //  tp_getattr
+    nullptr,                        //  tp_setattr
+    nullptr,                        //  tp_compare
+    nullptr,                        //  tp_repr
+    nullptr,                        //  tp_as_number
+    nullptr,                        //  tp_as_sequence
+    nullptr,                        //  tp_as_mapping
+    nullptr,                        //  tp_hash
+    nullptr,                        //  tp_call
+    nullptr,                        //  tp_str
+    nullptr,                        //  tp_getattro
+    nullptr,                        //  tp_setattro
+    nullptr,                        //  tp_as_buffer
+    Py_TPFLAGS_DEFAULT,             //  tp_flags
+    "A scalar map iterator",        //  tp_doc
+    nullptr,                        //  tp_traverse
+    nullptr,                        //  tp_clear
+    nullptr,                        //  tp_richcompare
+    0,                              //  tp_weaklistoffset
+    PyObject_SelfIter,              //  tp_iter
+    MapReflectionFriend::IterNext,  //  tp_iternext
+    nullptr,                        //  tp_methods
+    nullptr,                        //  tp_members
+    nullptr,                        //  tp_getset
+    nullptr,                        //  tp_base
+    nullptr,                        //  tp_dict
+    nullptr,                        //  tp_descr_get
+    nullptr,                        //  tp_descr_set
+    0,                              //  tp_dictoffset
+    nullptr,                        //  tp_init
+};
+
+bool InitMapContainers() {
+  // ScalarMapContainer_Type derives from our MutableMapping type.
+  ScopedPyObjectPtr abc(PyImport_ImportModule("collections.abc"));
+  if (abc == nullptr) {
+    return false;
+  }
+
+  ScopedPyObjectPtr mutable_mapping(
+      PyObject_GetAttrString(abc.get(), "MutableMapping"));
+  if (mutable_mapping == nullptr) {
+    return false;
+  }
+
+  Py_INCREF(mutable_mapping.get());
+  ScopedPyObjectPtr bases(PyTuple_Pack(1, mutable_mapping.get()));
+  if (bases == nullptr) {
+    return false;
+  }
+
+  ScalarMapContainer_Type = reinterpret_cast<PyTypeObject*>(
+      PyType_FromSpecWithBases(&ScalarMapContainer_Type_spec, bases.get()));
+
+  if (PyType_Ready(&MapIterator_Type) < 0) {
+    return false;
+  }
+
+  MessageMapContainer_Type = reinterpret_cast<PyTypeObject*>(
+      PyType_FromSpecWithBases(&MessageMapContainer_Type_spec, bases.get()));
+  return true;
+}
+
+}  // namespace python
+}  // namespace protobuf
+}  // namespace google
diff --git a/lark_channel/ws/pb/google/protobuf/pyext/map_container.h b/lark_channel/ws/pb/google/protobuf/pyext/map_container.h
new file mode 100644
index 0000000..e14136e
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/pyext/map_container.h
@@ -0,0 +1,90 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_PYTHON_CPP_MAP_CONTAINER_H__
+#define GOOGLE_PROTOBUF_PYTHON_CPP_MAP_CONTAINER_H__
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+#include <cstdint>
+#include <memory>
+
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/pyext/message.h>
+
+namespace google {
+namespace protobuf {
+
+class Message;
+
+namespace python {
+
+struct CMessageClass;
+
+// This struct is used directly for ScalarMap, and is the base class of
+// MessageMapContainer, which is used for MessageMap.
+struct MapContainer : public ContainerBase {
+  // Use to get a mutable message when necessary.
+  Message* GetMutableMessage();
+
+  // We bump this whenever we perform a mutation, to invalidate existing
+  // iterators.
+  uint64_t version;
+};
+
+struct MessageMapContainer : public MapContainer {
+  // The type used to create new child messages.
+  CMessageClass* message_class;
+};
+
+bool InitMapContainers();
+
+extern PyTypeObject* MessageMapContainer_Type;
+extern PyTypeObject* ScalarMapContainer_Type;
+extern PyTypeObject MapIterator_Type;  // Both map types use the same iterator.
+
+// Builds a MapContainer object, from a parent message and a
+// field descriptor.
+extern MapContainer* NewScalarMapContainer(
+    CMessage* parent, const FieldDescriptor* parent_field_descriptor);
+
+// Builds a MessageMap object, from a parent message and a
+// field descriptor.
+extern MessageMapContainer* NewMessageMapContainer(
+    CMessage* parent, const FieldDescriptor* parent_field_descriptor,
+    CMessageClass* message_class);
+
+}  // namespace python
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_PYTHON_CPP_MAP_CONTAINER_H__
diff --git a/lark_channel/ws/pb/google/protobuf/pyext/message.cc b/lark_channel/ws/pb/google/protobuf/pyext/message.cc
new file mode 100644
index 0000000..920c17d
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/pyext/message.cc
@@ -0,0 +1,3066 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: anuraag@google.com (Anuraag Agrawal)
+// Author: tibell@google.com (Johan Tibell)
+
+#include <google/protobuf/pyext/message.h>
+
+#include <structmember.h>  // A Python header file.
+
+#include <cstdint>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <google/protobuf/stubs/strutil.h>
+
+#ifndef PyVarObject_HEAD_INIT
+#define PyVarObject_HEAD_INIT(type, size) PyObject_HEAD_INIT(type) size,
+#endif
+#ifndef Py_TYPE
+#define Py_TYPE(ob) (((PyObject*)(ob))->ob_type)
+#endif
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
+#include <google/protobuf/descriptor.pb.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/text_format.h>
+#include <google/protobuf/unknown_field_set.h>
+#include <google/protobuf/pyext/descriptor.h>
+#include <google/protobuf/pyext/descriptor_pool.h>
+#include <google/protobuf/pyext/extension_dict.h>
+#include <google/protobuf/pyext/field.h>
+#include <google/protobuf/pyext/map_container.h>
+#include <google/protobuf/pyext/message_factory.h>
+#include <google/protobuf/pyext/repeated_composite_container.h>
+#include <google/protobuf/pyext/repeated_scalar_container.h>
+#include <google/protobuf/pyext/safe_numerics.h>
+#include <google/protobuf/pyext/scoped_pyobject_ptr.h>
+#include <google/protobuf/pyext/unknown_fields.h>
+#include <google/protobuf/util/message_differencer.h>
+#include <google/protobuf/io/strtod.h>
+#include <google/protobuf/stubs/map_util.h>
+
+// clang-format off
+#include <google/protobuf/port_def.inc>
+// clang-format on
+
+#define PyString_AsString(ob) \
+  (PyUnicode_Check(ob) ? PyUnicode_AsUTF8(ob) : PyBytes_AsString(ob))
+#define PyString_AsStringAndSize(ob, charpp, sizep)              \
+  (PyUnicode_Check(ob)                                           \
+       ? ((*(charpp) = const_cast<char*>(                        \
+               PyUnicode_AsUTF8AndSize(ob, (sizep)))) == nullptr \
+              ? -1                                               \
+              : 0)                                               \
+       : PyBytes_AsStringAndSize(ob, (charpp), (sizep)))
+
+namespace google {
+namespace protobuf {
+namespace python {
+
+class MessageReflectionFriend {
+ public:
+  static void UnsafeShallowSwapFields(
+      Message* lhs, Message* rhs,
+      const std::vector<const FieldDescriptor*>& fields) {
+    lhs->GetReflection()->UnsafeShallowSwapFields(lhs, rhs, fields);
+  }
+  static bool IsLazyField(const Reflection* reflection, const Message& message,
+                          const FieldDescriptor* field) {
+    return reflection->IsLazyField(field) ||
+           reflection->IsLazyExtension(message, field);
+  }
+};
+
+static PyObject* kDESCRIPTOR;
+PyObject* EnumTypeWrapper_class;
+static PyObject* PythonMessage_class;
+static PyObject* kEmptyWeakref;
+static PyObject* WKT_classes = nullptr;
+
+namespace message_meta {
+
+namespace {
+// Copied over from internal 'google/protobuf/stubs/strutil.h'.
+inline void LowerString(std::string* s) {
+  std::string::iterator end = s->end();
+  for (std::string::iterator i = s->begin(); i != end; ++i) {
+    // tolower() changes based on locale.  We don't want this!
+    if ('A' <= *i && *i <= 'Z') *i += 'a' - 'A';
+  }
+}
+}  // namespace
+
+// Finalize the creation of the Message class.
+static int AddDescriptors(PyObject* cls, const Descriptor* descriptor) {
+  // For each field set: cls.<field>_FIELD_NUMBER = <number>
+  for (int i = 0; i < descriptor->field_count(); ++i) {
+    const FieldDescriptor* field_descriptor = descriptor->field(i);
+    ScopedPyObjectPtr property(NewFieldProperty(field_descriptor));
+    if (property == nullptr) {
+      return -1;
+    }
+    if (PyObject_SetAttrString(cls, field_descriptor->name().c_str(),
+                               property.get()) < 0) {
+      return -1;
+    }
+  }
+
+  // For each enum set cls.<enum name> = EnumTypeWrapper(<enum descriptor>).
+  for (int i = 0; i < descriptor->enum_type_count(); ++i) {
+    const EnumDescriptor* enum_descriptor = descriptor->enum_type(i);
+    ScopedPyObjectPtr enum_type(
+        PyEnumDescriptor_FromDescriptor(enum_descriptor));
+    if (enum_type == nullptr) {
+      return -1;
+    }
+    // Add wrapped enum type to message class.
+    ScopedPyObjectPtr wrapped(PyObject_CallFunctionObjArgs(
+        EnumTypeWrapper_class, enum_type.get(), nullptr));
+    if (wrapped == nullptr) {
+      return -1;
+    }
+    if (PyObject_SetAttrString(
+            cls, enum_descriptor->name().c_str(), wrapped.get()) == -1) {
+      return -1;
+    }
+
+    // For each enum value add cls.<name> = <number>
+    for (int j = 0; j < enum_descriptor->value_count(); ++j) {
+      const EnumValueDescriptor* enum_value_descriptor =
+          enum_descriptor->value(j);
+      ScopedPyObjectPtr value_number(
+          PyLong_FromLong(enum_value_descriptor->number()));
+      if (value_number == nullptr) {
+        return -1;
+      }
+      if (PyObject_SetAttrString(cls, enum_value_descriptor->name().c_str(),
+                                 value_number.get()) == -1) {
+        return -1;
+      }
+    }
+  }
+
+  // For each extension set cls.<extension name> = <extension descriptor>.
+  //
+  // Extension descriptors come from
+  // <message descriptor>.extensions_by_name[name]
+  // which was defined previously.
+  for (int i = 0; i < descriptor->extension_count(); ++i) {
+    const google::protobuf::FieldDescriptor* field = descriptor->extension(i);
+    ScopedPyObjectPtr extension_field(PyFieldDescriptor_FromDescriptor(field));
+    if (extension_field == nullptr) {
+      return -1;
+    }
+
+    // Add the extension field to the message class.
+    if (PyObject_SetAttrString(
+            cls, field->name().c_str(), extension_field.get()) == -1) {
+      return -1;
+    }
+  }
+
+  return 0;
+}
+
+static PyObject* New(PyTypeObject* type, PyObject* args, PyObject* kwargs) {
+  static const char* kwlist[] = {"name", "bases", "dict", nullptr};
+  PyObject *bases, *dict;
+  const char* name;
+
+  // Check arguments: (name, bases, dict)
+  if (!PyArg_ParseTupleAndKeywords(
+          args, kwargs, "sO!O!:type", const_cast<char**>(kwlist), &name,
+          &PyTuple_Type, &bases, &PyDict_Type, &dict)) {
+    return nullptr;
+  }
+
+  // Check bases: only (), or (message.Message,) are allowed
+  if (!(PyTuple_GET_SIZE(bases) == 0 ||
+        (PyTuple_GET_SIZE(bases) == 1 &&
+         PyTuple_GET_ITEM(bases, 0) == PythonMessage_class))) {
+    PyErr_SetString(PyExc_TypeError,
+                    "A Message class can only inherit from Message");
+    return nullptr;
+  }
+
+  // Check dict['DESCRIPTOR']
+  PyObject* py_descriptor = PyDict_GetItem(dict, kDESCRIPTOR);
+  if (py_descriptor == nullptr) {
+    PyErr_SetString(PyExc_TypeError, "Message class has no DESCRIPTOR");
+    return nullptr;
+  }
+  if (!PyObject_TypeCheck(py_descriptor, &PyMessageDescriptor_Type)) {
+    PyErr_Format(PyExc_TypeError, "Expected a message Descriptor, got %s",
+                 py_descriptor->ob_type->tp_name);
+    return nullptr;
+  }
+  const Descriptor* message_descriptor =
+      PyMessageDescriptor_AsDescriptor(py_descriptor);
+  if (message_descriptor == nullptr) {
+    return nullptr;
+  }
+
+  // Messages have no __dict__
+  ScopedPyObjectPtr slots(PyTuple_New(0));
+  if (PyDict_SetItemString(dict, "__slots__", slots.get()) < 0) {
+    return nullptr;
+  }
+
+  // Build the arguments to the base metaclass.
+  // We change the __bases__ classes.
+  ScopedPyObjectPtr new_args;
+
+  if (WKT_classes == nullptr) {
+    ScopedPyObjectPtr well_known_types(PyImport_ImportModule(
+        "google.protobuf.internal.well_known_types"));
+    GOOGLE_DCHECK(well_known_types != nullptr);
+
+    WKT_classes = PyObject_GetAttrString(well_known_types.get(), "WKTBASES");
+    GOOGLE_DCHECK(WKT_classes != nullptr);
+  }
+
+  PyObject* well_known_class = PyDict_GetItemString(
+      WKT_classes, message_descriptor->full_name().c_str());
+  if (well_known_class == nullptr) {
+    new_args.reset(Py_BuildValue("s(OO)O", name, CMessage_Type,
+                                 PythonMessage_class, dict));
+  } else {
+    new_args.reset(Py_BuildValue("s(OOO)O", name, CMessage_Type,
+                                 PythonMessage_class, well_known_class, dict));
+  }
+
+  if (new_args == nullptr) {
+    return nullptr;
+  }
+  // Call the base metaclass.
+  ScopedPyObjectPtr result(PyType_Type.tp_new(type, new_args.get(), nullptr));
+  if (result == nullptr) {
+    return nullptr;
+  }
+  CMessageClass* newtype = reinterpret_cast<CMessageClass*>(result.get());
+
+  // Cache the descriptor, both as Python object and as C++ pointer.
+  const Descriptor* descriptor =
+      PyMessageDescriptor_AsDescriptor(py_descriptor);
+  if (descriptor == nullptr) {
+    return nullptr;
+  }
+  Py_INCREF(py_descriptor);
+  newtype->py_message_descriptor = py_descriptor;
+  newtype->message_descriptor = descriptor;
+  // TODO(amauryfa): Don't always use the canonical pool of the descriptor,
+  // use the MessageFactory optionally passed in the class dict.
+  PyDescriptorPool* py_descriptor_pool =
+      GetDescriptorPool_FromPool(descriptor->file()->pool());
+  if (py_descriptor_pool == nullptr) {
+    return nullptr;
+  }
+  newtype->py_message_factory = py_descriptor_pool->py_message_factory;
+  Py_INCREF(newtype->py_message_factory);
+
+  // Register the message in the MessageFactory.
+  // TODO(amauryfa): Move this call to MessageFactory.GetPrototype() when the
+  // MessageFactory is fully implemented in C++.
+  if (message_factory::RegisterMessageClass(newtype->py_message_factory,
+                                            descriptor, newtype) < 0) {
+    return nullptr;
+  }
+
+  // Continue with type initialization: add other descriptors, enum values...
+  if (AddDescriptors(result.get(), descriptor) < 0) {
+    return nullptr;
+  }
+  return result.release();
+}
+
+static void Dealloc(PyObject* pself) {
+  CMessageClass* self = reinterpret_cast<CMessageClass*>(pself);
+  Py_XDECREF(self->py_message_descriptor);
+  Py_XDECREF(self->py_message_factory);
+  return PyType_Type.tp_dealloc(pself);
+}
+
+static int GcTraverse(PyObject* pself, visitproc visit, void* arg) {
+  CMessageClass* self = reinterpret_cast<CMessageClass*>(pself);
+  Py_VISIT(self->py_message_descriptor);
+  Py_VISIT(self->py_message_factory);
+  return PyType_Type.tp_traverse(pself, visit, arg);
+}
+
+static int GcClear(PyObject* pself) {
+  // It's important to keep the descriptor and factory alive, until the
+  // C++ message is fully destructed.
+  return PyType_Type.tp_clear(pself);
+}
+
+// The _extensions_by_name dictionary is built on every access.
+// TODO(amauryfa): Migrate all users to pool.FindAllExtensions()
+static PyObject* GetExtensionsByName(CMessageClass *self, void *closure) {
+  if (self->message_descriptor == nullptr) {
+    // This is the base Message object, simply raise AttributeError.
+    PyErr_SetString(PyExc_AttributeError,
+                    "Base Message class has no DESCRIPTOR");
+    return nullptr;
+  }
+
+  const PyDescriptorPool* pool = self->py_message_factory->pool;
+
+  std::vector<const FieldDescriptor*> extensions;
+  pool->pool->FindAllExtensions(self->message_descriptor, &extensions);
+
+  ScopedPyObjectPtr result(PyDict_New());
+  for (int i = 0; i < extensions.size(); i++) {
+    ScopedPyObjectPtr extension(
+        PyFieldDescriptor_FromDescriptor(extensions[i]));
+    if (extension == nullptr) {
+      return nullptr;
+    }
+    if (PyDict_SetItemString(result.get(), extensions[i]->full_name().c_str(),
+                             extension.get()) < 0) {
+      return nullptr;
+    }
+  }
+  return result.release();
+}
+
+// The _extensions_by_number dictionary is built on every access.
+// TODO(amauryfa): Migrate all users to pool.FindExtensionByNumber()
+static PyObject* GetExtensionsByNumber(CMessageClass *self, void *closure) {
+  if (self->message_descriptor == nullptr) {
+    // This is the base Message object, simply raise AttributeError.
+    PyErr_SetString(PyExc_AttributeError,
+                    "Base Message class has no DESCRIPTOR");
+    return nullptr;
+  }
+
+  const PyDescriptorPool* pool = self->py_message_factory->pool;
+
+  std::vector<const FieldDescriptor*> extensions;
+  pool->pool->FindAllExtensions(self->message_descriptor, &extensions);
+
+  ScopedPyObjectPtr result(PyDict_New());
+  for (int i = 0; i < extensions.size(); i++) {
+    ScopedPyObjectPtr extension(
+        PyFieldDescriptor_FromDescriptor(extensions[i]));
+    if (extension == nullptr) {
+      return nullptr;
+    }
+    ScopedPyObjectPtr number(PyLong_FromLong(extensions[i]->number()));
+    if (number == nullptr) {
+      return nullptr;
+    }
+    if (PyDict_SetItem(result.get(), number.get(), extension.get()) < 0) {
+      return nullptr;
+    }
+  }
+  return result.release();
+}
+
+static PyGetSetDef Getters[] = {
+    {"_extensions_by_name", (getter)GetExtensionsByName, nullptr},
+    {"_extensions_by_number", (getter)GetExtensionsByNumber, nullptr},
+    {nullptr},
+};
+
+// Compute some class attributes on the fly:
+// - All the _FIELD_NUMBER attributes, for all fields and nested extensions.
+// Returns a new reference, or NULL with an exception set.
+static PyObject* GetClassAttribute(CMessageClass *self, PyObject* name) {
+  char* attr;
+  Py_ssize_t attr_size;
+  static const char kSuffix[] = "_FIELD_NUMBER";
+  if (PyString_AsStringAndSize(name, &attr, &attr_size) >= 0 &&
+      HasSuffixString(StringPiece(attr, attr_size), kSuffix)) {
+    std::string field_name(attr, attr_size - sizeof(kSuffix) + 1);
+    LowerString(&field_name);
+
+    // Try to find a field with the given name, without the suffix.
+    const FieldDescriptor* field =
+        self->message_descriptor->FindFieldByLowercaseName(field_name);
+    if (!field) {
+      // Search nested extensions as well.
+      field =
+          self->message_descriptor->FindExtensionByLowercaseName(field_name);
+    }
+    if (field) {
+      return PyLong_FromLong(field->number());
+    }
+  }
+  PyErr_SetObject(PyExc_AttributeError, name);
+  return nullptr;
+}
+
+static PyObject* GetAttr(CMessageClass* self, PyObject* name) {
+  PyObject* result = CMessageClass_Type->tp_base->tp_getattro(
+      reinterpret_cast<PyObject*>(self), name);
+  if (result != nullptr) {
+    return result;
+  }
+  if (!PyErr_ExceptionMatches(PyExc_AttributeError)) {
+    return nullptr;
+  }
+
+  PyErr_Clear();
+  return GetClassAttribute(self, name);
+}
+
+}  // namespace message_meta
+
+// Protobuf has a 64MB limit built in, this variable will override this. Please
+// do not enable this unless you fully understand the implications: protobufs
+// must all be kept in memory at the same time, so if they grow too big you may
+// get OOM errors. The protobuf APIs do not provide any tools for processing
+// protobufs in chunks.  If you have protos this big you should break them up if
+// it is at all convenient to do so.
+#ifdef PROTOBUF_PYTHON_ALLOW_OVERSIZE_PROTOS
+static bool allow_oversize_protos = true;
+#else
+static bool allow_oversize_protos = false;
+#endif
+
+static PyTypeObject _CMessageClass_Type = {
+    PyVarObject_HEAD_INIT(&PyType_Type, 0) FULL_MODULE_NAME
+    ".MessageMeta",         // tp_name
+    sizeof(CMessageClass),  // tp_basicsize
+    0,                      // tp_itemsize
+    message_meta::Dealloc,  // tp_dealloc
+#if PY_VERSION_HEX < 0x03080000
+    nullptr, /* tp_print */
+#else
+    0, /* tp_vectorcall_offset */
+#endif
+    nullptr,                              // tp_getattr
+    nullptr,                              // tp_setattr
+    nullptr,                              // tp_compare
+    nullptr,                              // tp_repr
+    nullptr,                              // tp_as_number
+    nullptr,                              // tp_as_sequence
+    nullptr,                              // tp_as_mapping
+    nullptr,                              // tp_hash
+    nullptr,                              // tp_call
+    nullptr,                              // tp_str
+    (getattrofunc)message_meta::GetAttr,  // tp_getattro
+    nullptr,                              // tp_setattro
+    nullptr,                              // tp_as_buffer
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,  // tp_flags
+    "The metaclass of ProtocolMessages",                            // tp_doc
+    message_meta::GcTraverse,  // tp_traverse
+    message_meta::GcClear,     // tp_clear
+    nullptr,                   // tp_richcompare
+    0,                         // tp_weaklistoffset
+    nullptr,                   // tp_iter
+    nullptr,                   // tp_iternext
+    nullptr,                   // tp_methods
+    nullptr,                   // tp_members
+    message_meta::Getters,     // tp_getset
+    nullptr,                   // tp_base
+    nullptr,                   // tp_dict
+    nullptr,                   // tp_descr_get
+    nullptr,                   // tp_descr_set
+    0,                         // tp_dictoffset
+    nullptr,                   // tp_init
+    nullptr,                   // tp_alloc
+    message_meta::New,         // tp_new
+};
+PyTypeObject* CMessageClass_Type = &_CMessageClass_Type;
+
+static CMessageClass* CheckMessageClass(PyTypeObject* cls) {
+  if (!PyObject_TypeCheck(cls, CMessageClass_Type)) {
+    PyErr_Format(PyExc_TypeError, "Class %s is not a Message", cls->tp_name);
+    return nullptr;
+  }
+  return reinterpret_cast<CMessageClass*>(cls);
+}
+
+static const Descriptor* GetMessageDescriptor(PyTypeObject* cls) {
+  CMessageClass* type = CheckMessageClass(cls);
+  if (type == nullptr) {
+    return nullptr;
+  }
+  return type->message_descriptor;
+}
+
+// Forward declarations
+namespace cmessage {
+int InternalReleaseFieldByDescriptor(
+    CMessage* self,
+    const FieldDescriptor* field_descriptor);
+}  // namespace cmessage
+
+// ---------------------------------------------------------------------
+
+PyObject* EncodeError_class;
+PyObject* DecodeError_class;
+PyObject* PickleError_class;
+
+// Format an error message for unexpected types.
+// Always return with an exception set.
+void FormatTypeError(PyObject* arg, const char* expected_types) {
+  // This function is often called with an exception set.
+  // Clear it to call PyObject_Repr() in good conditions.
+  PyErr_Clear();
+  PyObject* repr = PyObject_Repr(arg);
+  if (repr) {
+    PyErr_Format(PyExc_TypeError,
+                 "%.100s has type %.100s, but expected one of: %s",
+                 PyString_AsString(repr),
+                 Py_TYPE(arg)->tp_name,
+                 expected_types);
+    Py_DECREF(repr);
+  }
+}
+
+void OutOfRangeError(PyObject* arg) {
+  PyObject *s = PyObject_Str(arg);
+  if (s) {
+    PyErr_Format(PyExc_ValueError,
+                 "Value out of range: %s",
+                 PyString_AsString(s));
+    Py_DECREF(s);
+  }
+}
+
+template<class RangeType, class ValueType>
+bool VerifyIntegerCastAndRange(PyObject* arg, ValueType value) {
+  if (PROTOBUF_PREDICT_FALSE(value == -1 && PyErr_Occurred())) {
+    if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
+      // Replace it with the same ValueError as pure python protos instead of
+      // the default one.
+      PyErr_Clear();
+      OutOfRangeError(arg);
+    }  // Otherwise propagate existing error.
+    return false;
+  }
+  if (PROTOBUF_PREDICT_FALSE(!IsValidNumericCast<RangeType>(value))) {
+    OutOfRangeError(arg);
+    return false;
+  }
+  return true;
+}
+
+template <class T>
+bool CheckAndGetInteger(PyObject* arg, T* value) {
+  // This effectively defines an integer as "an object that can be cast as
+  // an integer and can be used as an ordinal number".
+  // This definition includes everything with a valid __index__() implementation
+  // and shouldn't cast the net too wide.
+  if (!strcmp(Py_TYPE(arg)->tp_name, "numpy.ndarray") ||
+      PROTOBUF_PREDICT_FALSE(!PyIndex_Check(arg))) {
+    FormatTypeError(arg, "int");
+    return false;
+  }
+
+  PyObject* arg_py_int = PyNumber_Index(arg);
+  if (PyErr_Occurred()) {
+    // Propagate existing error.
+    return false;
+  }
+
+  if (std::numeric_limits<T>::min() == 0) {
+    // Unsigned case.
+    unsigned PY_LONG_LONG ulong_result = PyLong_AsUnsignedLongLong(arg_py_int);
+    Py_DECREF(arg_py_int);
+    if (VerifyIntegerCastAndRange<T, unsigned PY_LONG_LONG>(arg,
+                                                            ulong_result)) {
+      *value = static_cast<T>(ulong_result);
+    } else {
+      return false;
+    }
+  } else {
+    // Signed case.
+    Py_DECREF(arg_py_int);
+    PY_LONG_LONG long_result = PyLong_AsLongLong(arg);
+    if (VerifyIntegerCastAndRange<T, PY_LONG_LONG>(arg, long_result)) {
+      *value = static_cast<T>(long_result);
+    } else {
+      return false;
+    }
+  }
+  return true;
+}
+
+// These are referenced by repeated_scalar_container, and must
+// be explicitly instantiated.
+template bool CheckAndGetInteger<int32>(PyObject*, int32*);
+template bool CheckAndGetInteger<int64>(PyObject*, int64*);
+template bool CheckAndGetInteger<uint32>(PyObject*, uint32*);
+template bool CheckAndGetInteger<uint64>(PyObject*, uint64*);
+
+bool CheckAndGetDouble(PyObject* arg, double* value) {
+  *value = PyFloat_AsDouble(arg);
+  if (!strcmp(Py_TYPE(arg)->tp_name, "numpy.ndarray") ||
+      PROTOBUF_PREDICT_FALSE(*value == -1 && PyErr_Occurred())) {
+    FormatTypeError(arg, "int, float");
+    return false;
+  }
+  return true;
+}
+
+bool CheckAndGetFloat(PyObject* arg, float* value) {
+  double double_value;
+  if (!CheckAndGetDouble(arg, &double_value)) {
+    return false;
+  }
+  *value = io::SafeDoubleToFloat(double_value);
+  return true;
+}
+
+bool CheckAndGetBool(PyObject* arg, bool* value) {
+  long long_value = PyLong_AsLong(arg);  // NOLINT
+  if (!strcmp(Py_TYPE(arg)->tp_name, "numpy.ndarray") ||
+      (long_value == -1 && PyErr_Occurred())) {
+    FormatTypeError(arg, "int, bool");
+    return false;
+  }
+  *value = static_cast<bool>(long_value);
+
+  return true;
+}
+
+// Checks whether the given object (which must be "bytes" or "unicode") contains
+// valid UTF-8.
+bool IsValidUTF8(PyObject* obj) {
+  if (PyBytes_Check(obj)) {
+    PyObject* unicode = PyUnicode_FromEncodedObject(obj, "utf-8", nullptr);
+
+    // Clear the error indicator; we report our own error when desired.
+    PyErr_Clear();
+
+    if (unicode) {
+      Py_DECREF(unicode);
+      return true;
+    } else {
+      return false;
+    }
+  } else {
+    // Unicode object, known to be valid UTF-8.
+    return true;
+  }
+}
+
+bool AllowInvalidUTF8(const FieldDescriptor* field) { return false; }
+
+PyObject* CheckString(PyObject* arg, const FieldDescriptor* descriptor) {
+  GOOGLE_DCHECK(descriptor->type() == FieldDescriptor::TYPE_STRING ||
+         descriptor->type() == FieldDescriptor::TYPE_BYTES);
+  if (descriptor->type() == FieldDescriptor::TYPE_STRING) {
+    if (!PyBytes_Check(arg) && !PyUnicode_Check(arg)) {
+      FormatTypeError(arg, "bytes, unicode");
+      return nullptr;
+    }
+
+    if (!IsValidUTF8(arg) && !AllowInvalidUTF8(descriptor)) {
+      PyObject* repr = PyObject_Repr(arg);
+      PyErr_Format(PyExc_ValueError,
+                   "%s has type str, but isn't valid UTF-8 "
+                   "encoding. Non-UTF-8 strings must be converted to "
+                   "unicode objects before being added.",
+                   PyString_AsString(repr));
+      Py_DECREF(repr);
+      return nullptr;
+    }
+  } else if (!PyBytes_Check(arg)) {
+    FormatTypeError(arg, "bytes");
+    return nullptr;
+  }
+
+  PyObject* encoded_string = nullptr;
+  if (descriptor->type() == FieldDescriptor::TYPE_STRING) {
+    if (PyBytes_Check(arg)) {
+      // The bytes were already validated as correctly encoded UTF-8 above.
+      encoded_string = arg;  // Already encoded.
+      Py_INCREF(encoded_string);
+    } else {
+      encoded_string = PyUnicode_AsEncodedString(arg, "utf-8", nullptr);
+    }
+  } else {
+    // In this case field type is "bytes".
+    encoded_string = arg;
+    Py_INCREF(encoded_string);
+  }
+
+  return encoded_string;
+}
+
+bool CheckAndSetString(
+    PyObject* arg, Message* message,
+    const FieldDescriptor* descriptor,
+    const Reflection* reflection,
+    bool append,
+    int index) {
+  ScopedPyObjectPtr encoded_string(CheckString(arg, descriptor));
+
+  if (encoded_string.get() == nullptr) {
+    return false;
+  }
+
+  char* value;
+  Py_ssize_t value_len;
+  if (PyBytes_AsStringAndSize(encoded_string.get(), &value, &value_len) < 0) {
+    return false;
+  }
+
+  std::string value_string(value, value_len);
+  if (append) {
+    reflection->AddString(message, descriptor, std::move(value_string));
+  } else if (index < 0) {
+    reflection->SetString(message, descriptor, std::move(value_string));
+  } else {
+    reflection->SetRepeatedString(message, descriptor, index,
+                                  std::move(value_string));
+  }
+  return true;
+}
+
+PyObject* ToStringObject(const FieldDescriptor* descriptor,
+                         const std::string& value) {
+  if (descriptor->type() != FieldDescriptor::TYPE_STRING) {
+    return PyBytes_FromStringAndSize(value.c_str(), value.length());
+  }
+
+  PyObject* result =
+      PyUnicode_DecodeUTF8(value.c_str(), value.length(), nullptr);
+  // If the string can't be decoded in UTF-8, just return a string object that
+  // contains the raw bytes. This can't happen if the value was assigned using
+  // the members of the Python message object, but can happen if the values were
+  // parsed from the wire (binary).
+  if (result == nullptr) {
+    PyErr_Clear();
+    result = PyBytes_FromStringAndSize(value.c_str(), value.length());
+  }
+  return result;
+}
+
+bool CheckFieldBelongsToMessage(const FieldDescriptor* field_descriptor,
+                                const Message* message) {
+  if (message->GetDescriptor() == field_descriptor->containing_type()) {
+    return true;
+  }
+  PyErr_Format(PyExc_KeyError, "Field '%s' does not belong to message '%s'",
+               field_descriptor->full_name().c_str(),
+               message->GetDescriptor()->full_name().c_str());
+  return false;
+}
+
+namespace cmessage {
+
+PyMessageFactory* GetFactoryForMessage(CMessage* message) {
+  GOOGLE_DCHECK(PyObject_TypeCheck(message, CMessage_Type));
+  return reinterpret_cast<CMessageClass*>(Py_TYPE(message))->py_message_factory;
+}
+
+static int MaybeReleaseOverlappingOneofField(
+    CMessage* cmessage,
+    const FieldDescriptor* field) {
+  Message* message = cmessage->message;
+  const Reflection* reflection = message->GetReflection();
+  if (!field->containing_oneof() ||
+      !reflection->HasOneof(*message, field->containing_oneof()) ||
+      reflection->HasField(*message, field)) {
+    // No other field in this oneof, no need to release.
+    return 0;
+  }
+
+  const OneofDescriptor* oneof = field->containing_oneof();
+  const FieldDescriptor* existing_field =
+      reflection->GetOneofFieldDescriptor(*message, oneof);
+  if (existing_field->cpp_type() != FieldDescriptor::CPPTYPE_MESSAGE) {
+    // Non-message fields don't need to be released.
+    return 0;
+  }
+  if (InternalReleaseFieldByDescriptor(cmessage, existing_field) < 0) {
+    return -1;
+  }
+  return 0;
+}
+
+// After a Merge, visit every sub-message that was read-only, and
+// eventually update their pointer if the Merge operation modified them.
+int FixupMessageAfterMerge(CMessage* self) {
+  if (!self->composite_fields) {
+    return 0;
+  }
+  PyMessageFactory* factory = GetFactoryForMessage(self);
+  for (const auto& item : *self->composite_fields) {
+    const FieldDescriptor* descriptor = item.first;
+    if (descriptor->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE &&
+        !descriptor->is_repeated()) {
+      CMessage* cmsg = reinterpret_cast<CMessage*>(item.second);
+      if (cmsg->read_only == false) {
+        return 0;
+      }
+      Message* message = self->message;
+      const Reflection* reflection = message->GetReflection();
+      if (reflection->HasField(*message, descriptor)) {
+        // Message used to be read_only, but is no longer. Get the new pointer
+        // and record it.
+        Message* mutable_message = reflection->MutableMessage(
+            message, descriptor, factory->message_factory);
+        cmsg->message = mutable_message;
+        cmsg->read_only = false;
+        if (FixupMessageAfterMerge(cmsg) < 0) {
+          return -1;
+        }
+      }
+    }
+  }
+
+  return 0;
+}
+
+// ---------------------------------------------------------------------
+// Making a message writable
+
+int AssureWritable(CMessage* self) {
+  if (self == nullptr || !self->read_only) {
+    return 0;
+  }
+
+  // Toplevel messages are always mutable.
+  GOOGLE_DCHECK(self->parent);
+
+  if (AssureWritable(self->parent) == -1) {
+    return -1;
+  }
+  // If this message is part of a oneof, there might be a field to release in
+  // the parent.
+  if (MaybeReleaseOverlappingOneofField(self->parent,
+                                        self->parent_field_descriptor) < 0) {
+    return -1;
+  }
+
+  // Make self->message writable.
+  Message* parent_message = self->parent->message;
+  const Reflection* reflection = parent_message->GetReflection();
+  Message* mutable_message = reflection->MutableMessage(
+      parent_message, self->parent_field_descriptor,
+      GetFactoryForMessage(self->parent)->message_factory);
+  if (mutable_message == nullptr) {
+    return -1;
+  }
+  self->message = mutable_message;
+  self->read_only = false;
+
+  return 0;
+}
+
+// --- Globals:
+
+// Retrieve a C++ FieldDescriptor for an extension handle.
+const FieldDescriptor* GetExtensionDescriptor(PyObject* extension) {
+  ScopedPyObjectPtr cdescriptor;
+  if (!PyObject_TypeCheck(extension, &PyFieldDescriptor_Type)) {
+    // Most callers consider extensions as a plain dictionary.  We should
+    // allow input which is not a field descriptor, and simply pretend it does
+    // not exist.
+    PyErr_SetObject(PyExc_KeyError, extension);
+    return nullptr;
+  }
+  return PyFieldDescriptor_AsDescriptor(extension);
+}
+
+// If value is a string, convert it into an enum value based on the labels in
+// descriptor, otherwise simply return value.  Always returns a new reference.
+static PyObject* GetIntegerEnumValue(const FieldDescriptor& descriptor,
+                                     PyObject* value) {
+  if (PyUnicode_Check(value)) {
+    const EnumDescriptor* enum_descriptor = descriptor.enum_type();
+    if (enum_descriptor == nullptr) {
+      PyErr_SetString(PyExc_TypeError, "not an enum field");
+      return nullptr;
+    }
+    char* enum_label;
+    Py_ssize_t size;
+    if (PyString_AsStringAndSize(value, &enum_label, &size) < 0) {
+      return nullptr;
+    }
+    const EnumValueDescriptor* enum_value_descriptor =
+        enum_descriptor->FindValueByName(StringParam(enum_label, size));
+    if (enum_value_descriptor == nullptr) {
+      PyErr_Format(PyExc_ValueError, "unknown enum label \"%s\"", enum_label);
+      return nullptr;
+    }
+    return PyLong_FromLong(enum_value_descriptor->number());
+  }
+  Py_INCREF(value);
+  return value;
+}
+
+// Delete a slice from a repeated field.
+// The only way to remove items in C++ protos is to delete the last one,
+// so we swap items to move the deleted ones at the end, and then strip the
+// sequence.
+int DeleteRepeatedField(
+    CMessage* self,
+    const FieldDescriptor* field_descriptor,
+    PyObject* slice) {
+  Py_ssize_t length, from, to, step, slice_length;
+  Message* message = self->message;
+  const Reflection* reflection = message->GetReflection();
+  int min, max;
+  length = reflection->FieldSize(*message, field_descriptor);
+
+  if (PySlice_Check(slice)) {
+    from = to = step = slice_length = 0;
+    PySlice_GetIndicesEx(slice, length, &from, &to, &step, &slice_length);
+    if (from < to) {
+      min = from;
+      max = to - 1;
+    } else {
+      min = to + 1;
+      max = from;
+    }
+  } else {
+    from = to = PyLong_AsLong(slice);
+    if (from == -1 && PyErr_Occurred()) {
+      PyErr_SetString(PyExc_TypeError, "list indices must be integers");
+      return -1;
+    }
+
+    if (from < 0) {
+      from = to = length + from;
+    }
+    step = 1;
+    min = max = from;
+
+    // Range check.
+    if (from < 0 || from >= length) {
+      PyErr_Format(PyExc_IndexError, "list assignment index out of range");
+      return -1;
+    }
+  }
+
+  Py_ssize_t i = from;
+  std::vector<bool> to_delete(length, false);
+  while (i >= min && i <= max) {
+    to_delete[i] = true;
+    i += step;
+  }
+
+  // Swap elements so that items to delete are at the end.
+  to = 0;
+  for (i = 0; i < length; ++i) {
+    if (!to_delete[i]) {
+      if (i != to) {
+        reflection->SwapElements(message, field_descriptor, i, to);
+      }
+      ++to;
+    }
+  }
+
+  Arena* arena = Arena::InternalGetArenaForAllocation(message);
+  GOOGLE_DCHECK_EQ(arena, nullptr)
+      << "python protobuf is expected to be allocated from heap";
+  // Remove items, starting from the end.
+  for (; length > to; length--) {
+    if (field_descriptor->cpp_type() != FieldDescriptor::CPPTYPE_MESSAGE) {
+      reflection->RemoveLast(message, field_descriptor);
+      continue;
+    }
+    // It seems that RemoveLast() is less efficient for sub-messages, and
+    // the memory is not completely released. Prefer ReleaseLast().
+    //
+    // To work around a debug hardening (PROTOBUF_FORCE_COPY_IN_RELEASE),
+    // explicitly use UnsafeArenaReleaseLast. To not break rare use cases where
+    // arena is used, we fallback to ReleaseLast (but GOOGLE_DCHECK to find/fix it).
+    //
+    // Note that arena is likely null and GOOGLE_DCHECK and ReleaesLast might be
+    // redundant. The current approach takes extra cautious path not to disrupt
+    // production.
+    Message* sub_message =
+        (arena == nullptr)
+            ? reflection->UnsafeArenaReleaseLast(message, field_descriptor)
+            : reflection->ReleaseLast(message, field_descriptor);
+    // If there is a live weak reference to an item being removed, we "Release"
+    // it, and it takes ownership of the message.
+    if (CMessage* released = self->MaybeReleaseSubMessage(sub_message)) {
+      released->message = sub_message;
+    } else {
+      // sub_message was not transferred, delete it.
+      delete sub_message;
+    }
+  }
+
+  return 0;
+}
+
+// Initializes fields of a message. Used in constructors.
+int InitAttributes(CMessage* self, PyObject* args, PyObject* kwargs) {
+  if (args != nullptr && PyTuple_Size(args) != 0) {
+    PyErr_SetString(PyExc_TypeError, "No positional arguments allowed");
+    return -1;
+  }
+
+  if (kwargs == nullptr) {
+    return 0;
+  }
+
+  Py_ssize_t pos = 0;
+  PyObject* name;
+  PyObject* value;
+  while (PyDict_Next(kwargs, &pos, &name, &value)) {
+    if (!(PyUnicode_Check(name))) {
+      PyErr_SetString(PyExc_ValueError, "Field name must be a string");
+      return -1;
+    }
+    ScopedPyObjectPtr property(
+        PyObject_GetAttr(reinterpret_cast<PyObject*>(Py_TYPE(self)), name));
+    if (property == nullptr ||
+        !PyObject_TypeCheck(property.get(), CFieldProperty_Type)) {
+      PyErr_Format(PyExc_ValueError, "Protocol message %s has no \"%s\" field.",
+                   self->message->GetDescriptor()->name().c_str(),
+                   PyString_AsString(name));
+      return -1;
+    }
+    const FieldDescriptor* descriptor =
+        reinterpret_cast<PyMessageFieldProperty*>(property.get())
+            ->field_descriptor;
+    if (value == Py_None) {
+      // field=None is the same as no field at all.
+      continue;
+    }
+    if (descriptor->is_map()) {
+      ScopedPyObjectPtr map(GetFieldValue(self, descriptor));
+      const FieldDescriptor* value_descriptor =
+          descriptor->message_type()->map_value();
+      if (value_descriptor->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
+        ScopedPyObjectPtr iter(PyObject_GetIter(value));
+        if (iter == nullptr) {
+          PyErr_Format(PyExc_TypeError, "Argument %s is not iterable",
+                       PyString_AsString(name));
+          return -1;
+        }
+        ScopedPyObjectPtr next;
+        while ((next.reset(PyIter_Next(iter.get()))) != nullptr) {
+          ScopedPyObjectPtr source_value(PyObject_GetItem(value, next.get()));
+          ScopedPyObjectPtr dest_value(PyObject_GetItem(map.get(), next.get()));
+          if (source_value.get() == nullptr || dest_value.get() == nullptr) {
+            return -1;
+          }
+          ScopedPyObjectPtr ok(PyObject_CallMethod(
+              dest_value.get(), "MergeFrom", "O", source_value.get()));
+          if (ok.get() == nullptr) {
+            return -1;
+          }
+        }
+      } else {
+        ScopedPyObjectPtr function_return;
+        function_return.reset(
+            PyObject_CallMethod(map.get(), "update", "O", value));
+        if (function_return.get() == nullptr) {
+          return -1;
+        }
+      }
+    } else if (descriptor->label() == FieldDescriptor::LABEL_REPEATED) {
+      ScopedPyObjectPtr container(GetFieldValue(self, descriptor));
+      if (container == nullptr) {
+        return -1;
+      }
+      if (descriptor->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
+        RepeatedCompositeContainer* rc_container =
+            reinterpret_cast<RepeatedCompositeContainer*>(container.get());
+        ScopedPyObjectPtr iter(PyObject_GetIter(value));
+        if (iter == nullptr) {
+          PyErr_SetString(PyExc_TypeError, "Value must be iterable");
+          return -1;
+        }
+        ScopedPyObjectPtr next;
+        while ((next.reset(PyIter_Next(iter.get()))) != nullptr) {
+          PyObject* kwargs = (PyDict_Check(next.get()) ? next.get() : nullptr);
+          ScopedPyObjectPtr new_msg(
+              repeated_composite_container::Add(rc_container, nullptr, kwargs));
+          if (new_msg == nullptr) {
+            return -1;
+          }
+          if (kwargs == nullptr) {
+            // next was not a dict, it's a message we need to merge
+            ScopedPyObjectPtr merged(MergeFrom(
+                reinterpret_cast<CMessage*>(new_msg.get()), next.get()));
+            if (merged.get() == nullptr) {
+              return -1;
+            }
+          }
+        }
+        if (PyErr_Occurred()) {
+          // Check to see how PyIter_Next() exited.
+          return -1;
+        }
+      } else if (descriptor->cpp_type() == FieldDescriptor::CPPTYPE_ENUM) {
+        RepeatedScalarContainer* rs_container =
+            reinterpret_cast<RepeatedScalarContainer*>(container.get());
+        ScopedPyObjectPtr iter(PyObject_GetIter(value));
+        if (iter == nullptr) {
+          PyErr_SetString(PyExc_TypeError, "Value must be iterable");
+          return -1;
+        }
+        ScopedPyObjectPtr next;
+        while ((next.reset(PyIter_Next(iter.get()))) != nullptr) {
+          ScopedPyObjectPtr enum_value(
+              GetIntegerEnumValue(*descriptor, next.get()));
+          if (enum_value == nullptr) {
+            return -1;
+          }
+          ScopedPyObjectPtr new_msg(repeated_scalar_container::Append(
+              rs_container, enum_value.get()));
+          if (new_msg == nullptr) {
+            return -1;
+          }
+        }
+        if (PyErr_Occurred()) {
+          // Check to see how PyIter_Next() exited.
+          return -1;
+        }
+      } else {
+        if (ScopedPyObjectPtr(repeated_scalar_container::Extend(
+                reinterpret_cast<RepeatedScalarContainer*>(container.get()),
+                value)) == nullptr) {
+          return -1;
+        }
+      }
+    } else if (descriptor->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
+      ScopedPyObjectPtr message(GetFieldValue(self, descriptor));
+      if (message == nullptr) {
+        return -1;
+      }
+      CMessage* cmessage = reinterpret_cast<CMessage*>(message.get());
+      if (PyDict_Check(value)) {
+        // Make the message exist even if the dict is empty.
+        AssureWritable(cmessage);
+        if (InitAttributes(cmessage, nullptr, value) < 0) {
+          return -1;
+        }
+      } else {
+        ScopedPyObjectPtr merged(MergeFrom(cmessage, value));
+        if (merged == nullptr) {
+          return -1;
+        }
+      }
+    } else {
+      ScopedPyObjectPtr new_val;
+      if (descriptor->cpp_type() == FieldDescriptor::CPPTYPE_ENUM) {
+        new_val.reset(GetIntegerEnumValue(*descriptor, value));
+        if (new_val == nullptr) {
+          return -1;
+        }
+        value = new_val.get();
+      }
+      if (SetFieldValue(self, descriptor, value) < 0) {
+        return -1;
+      }
+    }
+  }
+  return 0;
+}
+
+// Allocates an incomplete Python Message: the caller must fill self->message
+// and eventually self->parent.
+CMessage* NewEmptyMessage(CMessageClass* type) {
+  CMessage* self = reinterpret_cast<CMessage*>(
+      PyType_GenericAlloc(&type->super.ht_type, 0));
+  if (self == nullptr) {
+    return nullptr;
+  }
+
+  self->message = nullptr;
+  self->parent = nullptr;
+  self->parent_field_descriptor = nullptr;
+  self->read_only = false;
+
+  self->composite_fields = nullptr;
+  self->child_submessages = nullptr;
+
+  self->unknown_field_set = nullptr;
+
+  return self;
+}
+
+// The __new__ method of Message classes.
+// Creates a new C++ message and takes ownership.
+static CMessage* NewCMessage(CMessageClass* type) {
+  // Retrieve the message descriptor and the default instance (=prototype).
+  const Descriptor* message_descriptor = type->message_descriptor;
+  if (message_descriptor == nullptr) {
+    // This would be very unexpected since the CMessageClass has already
+    // been checked.
+    PyErr_Format(PyExc_TypeError,
+                 "CMessageClass object '%s' has no descriptor.",
+                 Py_TYPE(type)->tp_name);
+    return nullptr;
+  }
+  const Message* prototype =
+      type->py_message_factory->message_factory->GetPrototype(
+          message_descriptor);
+  if (prototype == nullptr) {
+    PyErr_SetString(PyExc_TypeError, message_descriptor->full_name().c_str());
+    return nullptr;
+  }
+
+  CMessage* self = NewEmptyMessage(type);
+  if (self == nullptr) {
+    return nullptr;
+  }
+  self->message = prototype->New(nullptr);  // Ensures no arena is used.
+  self->parent = nullptr;  // This message owns its data.
+  return self;
+}
+
+static PyObject* New(PyTypeObject* cls, PyObject* unused_args,
+                     PyObject* unused_kwargs) {
+  CMessageClass* type = CheckMessageClass(cls);
+  if (type == nullptr) {
+    return nullptr;
+  }
+  return reinterpret_cast<PyObject*>(NewCMessage(type));
+}
+
+// The __init__ method of Message classes.
+// It initializes fields from keywords passed to the constructor.
+static int Init(CMessage* self, PyObject* args, PyObject* kwargs) {
+  return InitAttributes(self, args, kwargs);
+}
+
+// ---------------------------------------------------------------------
+// Deallocating a CMessage
+
+static void Dealloc(CMessage* self) {
+  if (self->weakreflist) {
+    PyObject_ClearWeakRefs(reinterpret_cast<PyObject*>(self));
+  }
+  // At this point all dependent objects have been removed.
+  GOOGLE_DCHECK(!self->child_submessages || self->child_submessages->empty());
+  GOOGLE_DCHECK(!self->composite_fields || self->composite_fields->empty());
+  delete self->child_submessages;
+  delete self->composite_fields;
+  if (self->unknown_field_set) {
+    unknown_fields::Clear(
+        reinterpret_cast<PyUnknownFields*>(self->unknown_field_set));
+  }
+
+  CMessage* parent = self->parent;
+  if (!parent) {
+    // No parent, we own the message.
+    delete self->message;
+  } else if (parent->AsPyObject() == Py_None) {
+    // Message owned externally: Nothing to dealloc
+    Py_CLEAR(self->parent);
+  } else {
+    // Clear this message from its parent's map.
+    if (self->parent_field_descriptor->is_repeated()) {
+      if (parent->child_submessages)
+        parent->child_submessages->erase(self->message);
+    } else {
+      if (parent->composite_fields)
+        parent->composite_fields->erase(self->parent_field_descriptor);
+    }
+    Py_CLEAR(self->parent);
+  }
+  Py_TYPE(self)->tp_free(reinterpret_cast<PyObject*>(self));
+}
+
+// ---------------------------------------------------------------------
+
+
+PyObject* IsInitialized(CMessage* self, PyObject* args) {
+  PyObject* errors = nullptr;
+  if (!PyArg_ParseTuple(args, "|O", &errors)) {
+    return nullptr;
+  }
+  if (self->message->IsInitialized()) {
+    Py_RETURN_TRUE;
+  }
+  if (errors != nullptr) {
+    ScopedPyObjectPtr initialization_errors(
+        FindInitializationErrors(self));
+    if (initialization_errors == nullptr) {
+      return nullptr;
+    }
+    ScopedPyObjectPtr extend_name(PyUnicode_FromString("extend"));
+    if (extend_name == nullptr) {
+      return nullptr;
+    }
+    ScopedPyObjectPtr result(PyObject_CallMethodObjArgs(
+        errors, extend_name.get(), initialization_errors.get(), nullptr));
+    if (result == nullptr) {
+      return nullptr;
+    }
+  }
+  Py_RETURN_FALSE;
+}
+
+int HasFieldByDescriptor(CMessage* self,
+                         const FieldDescriptor* field_descriptor) {
+  Message* message = self->message;
+  if (!CheckFieldBelongsToMessage(field_descriptor, message)) {
+    return -1;
+  }
+  if (field_descriptor->label() == FieldDescriptor::LABEL_REPEATED) {
+    PyErr_SetString(PyExc_KeyError,
+                    "Field is repeated. A singular method is required.");
+    return -1;
+  }
+  return message->GetReflection()->HasField(*message, field_descriptor);
+}
+
+const FieldDescriptor* FindFieldWithOneofs(const Message* message,
+                                           ConstStringParam field_name,
+                                           bool* in_oneof) {
+  *in_oneof = false;
+  const Descriptor* descriptor = message->GetDescriptor();
+  const FieldDescriptor* field_descriptor =
+      descriptor->FindFieldByName(field_name);
+  if (field_descriptor != nullptr) {
+    return field_descriptor;
+  }
+  const OneofDescriptor* oneof_desc =
+      descriptor->FindOneofByName(field_name);
+  if (oneof_desc != nullptr) {
+    *in_oneof = true;
+    return message->GetReflection()->GetOneofFieldDescriptor(*message,
+                                                             oneof_desc);
+  }
+  return nullptr;
+}
+
+bool CheckHasPresence(const FieldDescriptor* field_descriptor, bool in_oneof) {
+  auto message_name = field_descriptor->containing_type()->name();
+  if (field_descriptor->label() == FieldDescriptor::LABEL_REPEATED) {
+    PyErr_Format(PyExc_ValueError,
+                 "Protocol message %s has no singular \"%s\" field.",
+                 message_name.c_str(), field_descriptor->name().c_str());
+    return false;
+  }
+
+  if (!field_descriptor->has_presence()) {
+    PyErr_Format(PyExc_ValueError,
+                 "Can't test non-optional, non-submessage field \"%s.%s\" for "
+                 "presence in proto3.",
+                 message_name.c_str(), field_descriptor->name().c_str());
+    return false;
+  }
+
+  return true;
+}
+
+PyObject* HasField(CMessage* self, PyObject* arg) {
+  char* field_name;
+  Py_ssize_t size;
+  field_name = const_cast<char*>(PyUnicode_AsUTF8AndSize(arg, &size));
+  if (!field_name) {
+    return nullptr;
+  }
+
+  Message* message = self->message;
+  bool is_in_oneof;
+  const FieldDescriptor* field_descriptor =
+      FindFieldWithOneofs(message, StringParam(field_name, size), &is_in_oneof);
+  if (field_descriptor == nullptr) {
+    if (!is_in_oneof) {
+      PyErr_Format(PyExc_ValueError, "Protocol message %s has no field %s.",
+                   message->GetDescriptor()->name().c_str(), field_name);
+      return nullptr;
+    } else {
+      Py_RETURN_FALSE;
+    }
+  }
+
+  if (!CheckHasPresence(field_descriptor, is_in_oneof)) {
+    return nullptr;
+  }
+
+  if (message->GetReflection()->HasField(*message, field_descriptor)) {
+    Py_RETURN_TRUE;
+  }
+
+  Py_RETURN_FALSE;
+}
+
+PyObject* ClearExtension(CMessage* self, PyObject* extension) {
+  const FieldDescriptor* descriptor = GetExtensionDescriptor(extension);
+  if (descriptor == nullptr) {
+    return nullptr;
+  }
+  if (ClearFieldByDescriptor(self, descriptor) < 0) {
+    return nullptr;
+  }
+  Py_RETURN_NONE;
+}
+
+PyObject* HasExtension(CMessage* self, PyObject* extension) {
+  const FieldDescriptor* descriptor = GetExtensionDescriptor(extension);
+  if (descriptor == nullptr) {
+    return nullptr;
+  }
+  int has_field = HasFieldByDescriptor(self, descriptor);
+  if (has_field < 0) {
+    return nullptr;
+  } else {
+    return PyBool_FromLong(has_field);
+  }
+}
+
+// ---------------------------------------------------------------------
+// Releasing messages
+//
+// The Python API's ClearField() and Clear() methods behave
+// differently than their C++ counterparts.  While the C++ versions
+// clears the children, the Python versions detaches the children,
+// without touching their content.  This impedance mismatch causes
+// some complexity in the implementation, which is captured in this
+// section.
+//
+// When one or multiple fields are cleared we need to:
+//
+// * Gather all child objects that need to be detached from the message.
+//   In composite_fields and child_submessages.
+//
+// * Create a new Python message of the same kind. Use SwapFields() to move
+//   data from the original message.
+//
+// * Change the parent of all child objects: update their strong reference
+//   to their parent, and move their presence in composite_fields and
+//   child_submessages.
+
+// ---------------------------------------------------------------------
+// Release a composite child of a CMessage
+
+static int InternalReparentFields(
+    CMessage* self, const std::vector<CMessage*>& messages_to_release,
+    const std::vector<ContainerBase*>& containers_to_release) {
+  if (messages_to_release.empty() && containers_to_release.empty()) {
+    return 0;
+  }
+
+  // Move all the passed sub_messages to another message.
+  CMessage* new_message = cmessage::NewEmptyMessage(self->GetMessageClass());
+  if (new_message == nullptr) {
+    return -1;
+  }
+  new_message->message = self->message->New(nullptr);
+  ScopedPyObjectPtr holder(reinterpret_cast<PyObject*>(new_message));
+  new_message->child_submessages = new CMessage::SubMessagesMap();
+  new_message->composite_fields = new CMessage::CompositeFieldsMap();
+  std::set<const FieldDescriptor*> fields_to_swap;
+
+  // In case this the removed fields are the last reference to a message, keep
+  // a reference.
+  Py_INCREF(self);
+
+  for (const auto& to_release : messages_to_release) {
+    fields_to_swap.insert(to_release->parent_field_descriptor);
+    // Reparent
+    Py_INCREF(new_message);
+    Py_DECREF(to_release->parent);
+    to_release->parent = new_message;
+    self->child_submessages->erase(to_release->message);
+    new_message->child_submessages->emplace(to_release->message, to_release);
+  }
+
+  for (const auto& to_release : containers_to_release) {
+    fields_to_swap.insert(to_release->parent_field_descriptor);
+    Py_INCREF(new_message);
+    Py_DECREF(to_release->parent);
+    to_release->parent = new_message;
+    self->composite_fields->erase(to_release->parent_field_descriptor);
+    new_message->composite_fields->emplace(to_release->parent_field_descriptor,
+                                           to_release);
+  }
+
+  if (self->message->GetArena() == new_message->message->GetArena()) {
+    MessageReflectionFriend::UnsafeShallowSwapFields(
+        self->message, new_message->message,
+        std::vector<const FieldDescriptor*>(fields_to_swap.begin(),
+                                            fields_to_swap.end()));
+  } else {
+    self->message->GetReflection()->SwapFields(
+        self->message, new_message->message,
+        std::vector<const FieldDescriptor*>(fields_to_swap.begin(),
+                                            fields_to_swap.end()));
+  }
+
+  // This might delete the Python message completely if all children were moved.
+  Py_DECREF(self);
+
+  return 0;
+}
+
+int InternalReleaseFieldByDescriptor(
+    CMessage* self,
+    const FieldDescriptor* field_descriptor) {
+  if (!field_descriptor->is_repeated() &&
+      field_descriptor->cpp_type() != FieldDescriptor::CPPTYPE_MESSAGE) {
+    // Single scalars are not in any cache.
+    return 0;
+  }
+  std::vector<CMessage*> messages_to_release;
+  std::vector<ContainerBase*> containers_to_release;
+  if (self->child_submessages && field_descriptor->is_repeated() &&
+      field_descriptor->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
+    for (const auto& child_item : *self->child_submessages) {
+      if (child_item.second->parent_field_descriptor == field_descriptor) {
+        messages_to_release.push_back(child_item.second);
+      }
+    }
+  }
+  if (self->composite_fields) {
+    CMessage::CompositeFieldsMap::iterator it =
+        self->composite_fields->find(field_descriptor);
+    if (it != self->composite_fields->end()) {
+      containers_to_release.push_back(it->second);
+    }
+  }
+
+  return InternalReparentFields(self, messages_to_release,
+                                containers_to_release);
+}
+
+int ClearFieldByDescriptor(CMessage* self,
+                           const FieldDescriptor* field_descriptor) {
+  if (!CheckFieldBelongsToMessage(field_descriptor, self->message)) {
+    return -1;
+  }
+  if (InternalReleaseFieldByDescriptor(self, field_descriptor) < 0) {
+    return -1;
+  }
+  AssureWritable(self);
+  Message* message = self->message;
+  message->GetReflection()->ClearField(message, field_descriptor);
+  return 0;
+}
+
+PyObject* ClearField(CMessage* self, PyObject* arg) {
+  char* field_name;
+  Py_ssize_t field_size;
+  if (PyString_AsStringAndSize(arg, &field_name, &field_size) < 0) {
+    return nullptr;
+  }
+  AssureWritable(self);
+  bool is_in_oneof;
+  const FieldDescriptor* field_descriptor = FindFieldWithOneofs(
+      self->message, StringParam(field_name, field_size), &is_in_oneof);
+  if (field_descriptor == nullptr) {
+    if (is_in_oneof) {
+      // We gave the name of a oneof, and none of its fields are set.
+      Py_RETURN_NONE;
+    } else {
+      PyErr_Format(PyExc_ValueError,
+                   "Protocol message has no \"%s\" field.", field_name);
+      return nullptr;
+    }
+  }
+
+  if (ClearFieldByDescriptor(self, field_descriptor) < 0) {
+    return nullptr;
+  }
+  Py_RETURN_NONE;
+}
+
+PyObject* Clear(CMessage* self) {
+  AssureWritable(self);
+  // Detach all current fields of this message
+  std::vector<CMessage*> messages_to_release;
+  std::vector<ContainerBase*> containers_to_release;
+  if (self->child_submessages) {
+    for (const auto& item : *self->child_submessages) {
+      messages_to_release.push_back(item.second);
+    }
+  }
+  if (self->composite_fields) {
+    for (const auto& item : *self->composite_fields) {
+      containers_to_release.push_back(item.second);
+    }
+  }
+  if (InternalReparentFields(self, messages_to_release, containers_to_release) <
+      0) {
+    return nullptr;
+  }
+  if (self->unknown_field_set) {
+    unknown_fields::Clear(
+        reinterpret_cast<PyUnknownFields*>(self->unknown_field_set));
+    self->unknown_field_set = nullptr;
+  }
+  self->message->Clear();
+  Py_RETURN_NONE;
+}
+
+// ---------------------------------------------------------------------
+
+static std::string GetMessageName(CMessage* self) {
+  if (self->parent_field_descriptor != nullptr) {
+    return self->parent_field_descriptor->full_name();
+  } else {
+    return self->message->GetDescriptor()->full_name();
+  }
+}
+
+static PyObject* InternalSerializeToString(
+    CMessage* self, PyObject* args, PyObject* kwargs,
+    bool require_initialized) {
+  // Parse the "deterministic" kwarg; defaults to False.
+  static const char* kwlist[] = {"deterministic", nullptr};
+  PyObject* deterministic_obj = Py_None;
+  if (!PyArg_ParseTupleAndKeywords(
+          args, kwargs, "|O", const_cast<char**>(kwlist), &deterministic_obj)) {
+    return nullptr;
+  }
+  // Preemptively convert to a bool first, so we don't need to back out of
+  // allocating memory if this raises an exception.
+  // NOTE: This is unused later if deterministic == Py_None, but that's fine.
+  int deterministic = PyObject_IsTrue(deterministic_obj);
+  if (deterministic < 0) {
+    return nullptr;
+  }
+
+  if (require_initialized && !self->message->IsInitialized()) {
+    ScopedPyObjectPtr errors(FindInitializationErrors(self));
+    if (errors == nullptr) {
+      return nullptr;
+    }
+    ScopedPyObjectPtr comma(PyUnicode_FromString(","));
+    if (comma == nullptr) {
+      return nullptr;
+    }
+    ScopedPyObjectPtr joined(
+        PyObject_CallMethod(comma.get(), "join", "O", errors.get()));
+    if (joined == nullptr) {
+      return nullptr;
+    }
+
+    // TODO(haberman): this is a (hopefully temporary) hack.  The unit testing
+    // infrastructure reloads all pure-Python modules for every test, but not
+    // C++ modules (because that's generally impossible:
+    // http://bugs.python.org/issue1144263).  But if we cache EncodeError, we'll
+    // return the EncodeError from a previous load of the module, which won't
+    // match a user's attempt to catch EncodeError.  So we have to look it up
+    // again every time.
+    ScopedPyObjectPtr message_module(PyImport_ImportModule(
+        "google.protobuf.message"));
+    if (message_module.get() == nullptr) {
+      return nullptr;
+    }
+
+    ScopedPyObjectPtr encode_error(
+        PyObject_GetAttrString(message_module.get(), "EncodeError"));
+    if (encode_error.get() == nullptr) {
+      return nullptr;
+    }
+    PyErr_Format(encode_error.get(),
+                 "Message %s is missing required fields: %s",
+                 GetMessageName(self).c_str(), PyString_AsString(joined.get()));
+    return nullptr;
+  }
+
+  // Ok, arguments parsed and errors checked, now encode to a string
+  const size_t size = self->message->ByteSizeLong();
+  if (size == 0) {
+    return PyBytes_FromString("");
+  }
+
+  if (size > INT_MAX) {
+    PyErr_Format(PyExc_ValueError,
+                 "Message %s exceeds maximum protobuf "
+                 "size of 2GB: %zu",
+                 GetMessageName(self).c_str(), size);
+    return nullptr;
+  }
+
+  PyObject* result = PyBytes_FromStringAndSize(nullptr, size);
+  if (result == nullptr) {
+    return nullptr;
+  }
+  io::ArrayOutputStream out(PyBytes_AS_STRING(result), size);
+  io::CodedOutputStream coded_out(&out);
+  if (deterministic_obj != Py_None) {
+    coded_out.SetSerializationDeterministic(deterministic);
+  }
+  self->message->SerializeWithCachedSizes(&coded_out);
+  GOOGLE_CHECK(!coded_out.HadError());
+  return result;
+}
+
+static PyObject* SerializeToString(
+    CMessage* self, PyObject* args, PyObject* kwargs) {
+  return InternalSerializeToString(self, args, kwargs,
+                                   /*require_initialized=*/true);
+}
+
+static PyObject* SerializePartialToString(
+    CMessage* self, PyObject* args, PyObject* kwargs) {
+  return InternalSerializeToString(self, args, kwargs,
+                                   /*require_initialized=*/false);
+}
+
+// Formats proto fields for ascii dumps using python formatting functions where
+// appropriate.
+class PythonFieldValuePrinter : public TextFormat::FastFieldValuePrinter {
+ public:
+  // Python has some differences from C++ when printing floating point numbers.
+  //
+  // 1) Trailing .0 is always printed.
+  // 2) (Python2) Output is rounded to 12 digits.
+  // 3) (Python3) The full precision of the double is preserved (and Python uses
+  //    David M. Gay's dtoa(), when the C++ code uses SimpleDtoa. There are some
+  //    differences, but they rarely happen)
+  //
+  // We override floating point printing with the C-API function for printing
+  // Python floats to ensure consistency.
+  void PrintFloat(float val,
+                  TextFormat::BaseTextGenerator* generator) const override {
+    PrintDouble(val, generator);
+  }
+  void PrintDouble(double val,
+                   TextFormat::BaseTextGenerator* generator) const override {
+    // This implementation is not highly optimized (it allocates two temporary
+    // Python objects) but it is simple and portable.  If this is shown to be a
+    // performance bottleneck, we can optimize it, but the results will likely
+    // be more complicated to accommodate the differing behavior of double
+    // formatting between Python 2 and Python 3.
+    //
+    // (Though a valid question is: do we really want to make out output
+    // dependent on the Python version?)
+    ScopedPyObjectPtr py_value(PyFloat_FromDouble(val));
+    if (!py_value.get()) {
+      return;
+    }
+
+    ScopedPyObjectPtr py_str(PyObject_Str(py_value.get()));
+    if (!py_str.get()) {
+      return;
+    }
+
+    generator->PrintString(PyString_AsString(py_str.get()));
+  }
+};
+
+static PyObject* ToStr(CMessage* self) {
+  TextFormat::Printer printer;
+  // Passes ownership
+  printer.SetDefaultFieldValuePrinter(new PythonFieldValuePrinter());
+  printer.SetHideUnknownFields(true);
+  std::string output;
+  if (!printer.PrintToString(*self->message, &output)) {
+    PyErr_SetString(PyExc_ValueError, "Unable to convert message to str");
+    return nullptr;
+  }
+  return PyUnicode_FromString(output.c_str());
+}
+
+PyObject* MergeFrom(CMessage* self, PyObject* arg) {
+  CMessage* other_message;
+  if (!PyObject_TypeCheck(arg, CMessage_Type)) {
+    PyErr_Format(PyExc_TypeError,
+                 "Parameter to MergeFrom() must be instance of same class: "
+                 "expected %s got %s.",
+                 self->message->GetDescriptor()->full_name().c_str(),
+                 Py_TYPE(arg)->tp_name);
+    return nullptr;
+  }
+
+  other_message = reinterpret_cast<CMessage*>(arg);
+  if (other_message->message->GetDescriptor() !=
+      self->message->GetDescriptor()) {
+    PyErr_Format(PyExc_TypeError,
+                 "Parameter to MergeFrom() must be instance of same class: "
+                 "expected %s got %s.",
+                 self->message->GetDescriptor()->full_name().c_str(),
+                 other_message->message->GetDescriptor()->full_name().c_str());
+    return nullptr;
+  }
+  AssureWritable(self);
+
+  self->message->MergeFrom(*other_message->message);
+  // Child message might be lazily created before MergeFrom. Make sure they
+  // are mutable at this point if child messages are really created.
+  if (FixupMessageAfterMerge(self) < 0) {
+    return nullptr;
+  }
+
+  Py_RETURN_NONE;
+}
+
+static PyObject* CopyFrom(CMessage* self, PyObject* arg) {
+  CMessage* other_message;
+  if (!PyObject_TypeCheck(arg, CMessage_Type)) {
+    PyErr_Format(PyExc_TypeError,
+                 "Parameter to CopyFrom() must be instance of same class: "
+                 "expected %s got %s.",
+                 self->message->GetDescriptor()->full_name().c_str(),
+                 Py_TYPE(arg)->tp_name);
+    return nullptr;
+  }
+
+  other_message = reinterpret_cast<CMessage*>(arg);
+
+  if (self == other_message) {
+    Py_RETURN_NONE;
+  }
+
+  if (other_message->message->GetDescriptor() !=
+      self->message->GetDescriptor()) {
+    PyErr_Format(PyExc_TypeError,
+                 "Parameter to CopyFrom() must be instance of same class: "
+                 "expected %s got %s.",
+                 self->message->GetDescriptor()->full_name().c_str(),
+                 other_message->message->GetDescriptor()->full_name().c_str());
+    return nullptr;
+  }
+
+  AssureWritable(self);
+
+  // CopyFrom on the message will not clean up self->composite_fields,
+  // which can leave us in an inconsistent state, so clear it out here.
+  (void)ScopedPyObjectPtr(Clear(self));
+
+  self->message->CopyFrom(*other_message->message);
+
+  Py_RETURN_NONE;
+}
+
+// Provide a method in the module to set allow_oversize_protos to a boolean
+// value. This method returns the newly value of allow_oversize_protos.
+PyObject* SetAllowOversizeProtos(PyObject* m, PyObject* arg) {
+  if (!arg || !PyBool_Check(arg)) {
+    PyErr_SetString(PyExc_TypeError,
+                    "Argument to SetAllowOversizeProtos must be boolean");
+    return nullptr;
+  }
+  allow_oversize_protos = PyObject_IsTrue(arg);
+  if (allow_oversize_protos) {
+    Py_RETURN_TRUE;
+  } else {
+    Py_RETURN_FALSE;
+  }
+}
+
+static PyObject* MergeFromString(CMessage* self, PyObject* arg) {
+  Py_buffer data;
+  if (PyObject_GetBuffer(arg, &data, PyBUF_SIMPLE) < 0) {
+    return nullptr;
+  }
+
+  AssureWritable(self);
+
+  PyMessageFactory* factory = GetFactoryForMessage(self);
+  int depth = allow_oversize_protos
+                  ? INT_MAX
+                  : io::CodedInputStream::GetDefaultRecursionLimit();
+  const char* ptr;
+  internal::ParseContext ctx(
+      depth, false, &ptr,
+      StringPiece(static_cast<const char*>(data.buf), data.len));
+  PyBuffer_Release(&data);
+  ctx.data().pool = factory->pool->pool;
+  ctx.data().factory = factory->message_factory;
+
+  ptr = self->message->_InternalParse(ptr, &ctx);
+
+  // Child message might be lazily created before MergeFrom. Make sure they
+  // are mutable at this point if child messages are really created.
+  if (FixupMessageAfterMerge(self) < 0) {
+    return nullptr;
+  }
+
+  // Python makes distinction in error message, between a general parse failure
+  // and in-correct ending on a terminating tag. Hence we need to be a bit more
+  // explicit in our correctness checks.
+  if (ptr == nullptr) {
+    // Parse error.
+    PyErr_Format(
+        DecodeError_class, "Error parsing message with type '%s'",
+        self->GetMessageClass()->message_descriptor->full_name().c_str());
+    return nullptr;
+  }
+  if (ctx.BytesUntilLimit(ptr) < 0) {
+    // The parser overshot the limit.
+    PyErr_Format(
+        DecodeError_class,
+        "Error parsing message as the message exceeded the protobuf limit "
+        "with type '%s'",
+        self->GetMessageClass()->message_descriptor->full_name().c_str());
+    return nullptr;
+  }
+
+  // ctx has an explicit limit set (length of string_view), so we have to
+  // check we ended at that limit.
+  if (!ctx.EndedAtLimit()) {
+    // TODO(jieluo): Raise error and return NULL instead.
+    // b/27494216
+    PyErr_Warn(nullptr, "Unexpected end-group tag: Not all data was converted");
+    return PyLong_FromLong(data.len - ctx.BytesUntilLimit(ptr));
+  }
+  return PyLong_FromLong(data.len);
+}
+
+static PyObject* ParseFromString(CMessage* self, PyObject* arg) {
+  if (ScopedPyObjectPtr(Clear(self)) == nullptr) {
+    return nullptr;
+  }
+  return MergeFromString(self, arg);
+}
+
+static PyObject* ByteSize(CMessage* self, PyObject* args) {
+  return PyLong_FromLong(self->message->ByteSizeLong());
+}
+
+PyObject* RegisterExtension(PyObject* cls, PyObject* extension_handle) {
+  const FieldDescriptor* descriptor =
+      GetExtensionDescriptor(extension_handle);
+  if (descriptor == nullptr) {
+    return nullptr;
+  }
+  if (!PyObject_TypeCheck(cls, CMessageClass_Type)) {
+    PyErr_Format(PyExc_TypeError, "Expected a message class, got %s",
+                 cls->ob_type->tp_name);
+    return nullptr;
+  }
+  CMessageClass *message_class = reinterpret_cast<CMessageClass*>(cls);
+  if (message_class == nullptr) {
+    return nullptr;
+  }
+  // If the extension was already registered, check that it is the same.
+  const FieldDescriptor* existing_extension =
+      message_class->py_message_factory->pool->pool->FindExtensionByNumber(
+          descriptor->containing_type(), descriptor->number());
+  if (existing_extension != nullptr && existing_extension != descriptor) {
+    PyErr_SetString(PyExc_ValueError, "Double registration of Extensions");
+    return nullptr;
+  }
+  Py_RETURN_NONE;
+}
+
+static PyObject* SetInParent(CMessage* self, PyObject* args) {
+  AssureWritable(self);
+  Py_RETURN_NONE;
+}
+
+static PyObject* WhichOneof(CMessage* self, PyObject* arg) {
+  Py_ssize_t name_size;
+  char *name_data;
+  if (PyString_AsStringAndSize(arg, &name_data, &name_size) < 0) return nullptr;
+  const OneofDescriptor* oneof_desc =
+      self->message->GetDescriptor()->FindOneofByName(
+          StringParam(name_data, name_size));
+  if (oneof_desc == nullptr) {
+    PyErr_Format(PyExc_ValueError,
+                 "Protocol message has no oneof \"%s\" field.", name_data);
+    return nullptr;
+  }
+  const FieldDescriptor* field_in_oneof =
+      self->message->GetReflection()->GetOneofFieldDescriptor(
+          *self->message, oneof_desc);
+  if (field_in_oneof == nullptr) {
+    Py_RETURN_NONE;
+  } else {
+    const std::string& name = field_in_oneof->name();
+    return PyUnicode_FromStringAndSize(name.c_str(), name.size());
+  }
+}
+
+static PyObject* GetExtensionDict(CMessage* self, void *closure);
+
+static PyObject* ListFields(CMessage* self) {
+  std::vector<const FieldDescriptor*> fields;
+  self->message->GetReflection()->ListFields(*self->message, &fields);
+
+  // Normally, the list will be exactly the size of the fields.
+  ScopedPyObjectPtr all_fields(PyList_New(fields.size()));
+  if (all_fields == nullptr) {
+    return nullptr;
+  }
+
+  // When there are unknown extensions, the py list will *not* contain
+  // the field information.  Thus the actual size of the py list will be
+  // smaller than the size of fields.  Set the actual size at the end.
+  Py_ssize_t actual_size = 0;
+  for (size_t i = 0; i < fields.size(); ++i) {
+    ScopedPyObjectPtr t(PyTuple_New(2));
+    if (t == nullptr) {
+      return nullptr;
+    }
+
+    if (fields[i]->is_extension()) {
+      ScopedPyObjectPtr extension_field(
+          PyFieldDescriptor_FromDescriptor(fields[i]));
+      if (extension_field == nullptr) {
+        return nullptr;
+      }
+      // With C++ descriptors, the field can always be retrieved, but for
+      // unknown extensions which have not been imported in Python code, there
+      // is no message class and we cannot retrieve the value.
+      // TODO(amauryfa): consider building the class on the fly!
+      if (fields[i]->message_type() != nullptr &&
+          message_factory::GetMessageClass(GetFactoryForMessage(self),
+                                           fields[i]->message_type()) ==
+              nullptr) {
+        PyErr_Clear();
+        continue;
+      }
+      ScopedPyObjectPtr extensions(GetExtensionDict(self, nullptr));
+      if (extensions == nullptr) {
+        return nullptr;
+      }
+      // 'extension' reference later stolen by PyTuple_SET_ITEM.
+      PyObject* extension = PyObject_GetItem(
+          extensions.get(), extension_field.get());
+      if (extension == nullptr) {
+        return nullptr;
+      }
+      PyTuple_SET_ITEM(t.get(), 0, extension_field.release());
+      // Steals reference to 'extension'
+      PyTuple_SET_ITEM(t.get(), 1, extension);
+    } else {
+      // Normal field
+      ScopedPyObjectPtr field_descriptor(
+          PyFieldDescriptor_FromDescriptor(fields[i]));
+      if (field_descriptor == nullptr) {
+        return nullptr;
+      }
+
+      PyObject* field_value = GetFieldValue(self, fields[i]);
+      if (field_value == nullptr) {
+        PyErr_SetString(PyExc_ValueError, fields[i]->name().c_str());
+        return nullptr;
+      }
+      PyTuple_SET_ITEM(t.get(), 0, field_descriptor.release());
+      PyTuple_SET_ITEM(t.get(), 1, field_value);
+    }
+    PyList_SET_ITEM(all_fields.get(), actual_size, t.release());
+    ++actual_size;
+  }
+  if (static_cast<size_t>(actual_size) != fields.size() &&
+      (PyList_SetSlice(all_fields.get(), actual_size, fields.size(), nullptr) <
+       0)) {
+    return nullptr;
+  }
+  return all_fields.release();
+}
+
+static PyObject* DiscardUnknownFields(CMessage* self) {
+  AssureWritable(self);
+  self->message->DiscardUnknownFields();
+  Py_RETURN_NONE;
+}
+
+PyObject* FindInitializationErrors(CMessage* self) {
+  Message* message = self->message;
+  std::vector<std::string> errors;
+  message->FindInitializationErrors(&errors);
+
+  PyObject* error_list = PyList_New(errors.size());
+  if (error_list == nullptr) {
+    return nullptr;
+  }
+  for (size_t i = 0; i < errors.size(); ++i) {
+    const std::string& error = errors[i];
+    PyObject* error_string =
+        PyUnicode_FromStringAndSize(error.c_str(), error.length());
+    if (error_string == nullptr) {
+      Py_DECREF(error_list);
+      return nullptr;
+    }
+    PyList_SET_ITEM(error_list, i, error_string);
+  }
+  return error_list;
+}
+
+static PyObject* RichCompare(CMessage* self, PyObject* other, int opid) {
+  // Only equality comparisons are implemented.
+  if (opid != Py_EQ && opid != Py_NE) {
+    Py_INCREF(Py_NotImplemented);
+    return Py_NotImplemented;
+  }
+  bool equals = true;
+  // If other is not a message, it cannot be equal.
+  if (!PyObject_TypeCheck(other, CMessage_Type)) {
+    equals = false;
+  } else {
+    // Otherwise, we have a CMessage whose message we can inspect.
+    const google::protobuf::Message* other_message =
+        reinterpret_cast<CMessage*>(other)->message;
+    // If messages don't have the same descriptors, they are not equal.
+    if (equals &&
+        self->message->GetDescriptor() != other_message->GetDescriptor()) {
+      equals = false;
+    }
+    // Check the message contents.
+    if (equals &&
+        !google::protobuf::util::MessageDifferencer::Equals(
+            *self->message, *reinterpret_cast<CMessage*>(other)->message)) {
+      equals = false;
+    }
+  }
+
+  if (equals ^ (opid == Py_EQ)) {
+    Py_RETURN_FALSE;
+  } else {
+    Py_RETURN_TRUE;
+  }
+}
+
+PyObject* InternalGetScalar(const Message* message,
+                            const FieldDescriptor* field_descriptor) {
+  const Reflection* reflection = message->GetReflection();
+
+  if (!CheckFieldBelongsToMessage(field_descriptor, message)) {
+    return nullptr;
+  }
+
+  PyObject* result = nullptr;
+  switch (field_descriptor->cpp_type()) {
+    case FieldDescriptor::CPPTYPE_INT32: {
+      int32_t value = reflection->GetInt32(*message, field_descriptor);
+      result = PyLong_FromLong(value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_INT64: {
+      int64_t value = reflection->GetInt64(*message, field_descriptor);
+      result = PyLong_FromLongLong(value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_UINT32: {
+      uint32_t value = reflection->GetUInt32(*message, field_descriptor);
+      result = PyLong_FromSsize_t(value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_UINT64: {
+      uint64_t value = reflection->GetUInt64(*message, field_descriptor);
+      result = PyLong_FromUnsignedLongLong(value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_FLOAT: {
+      float value = reflection->GetFloat(*message, field_descriptor);
+      result = PyFloat_FromDouble(value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_DOUBLE: {
+      double value = reflection->GetDouble(*message, field_descriptor);
+      result = PyFloat_FromDouble(value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_BOOL: {
+      bool value = reflection->GetBool(*message, field_descriptor);
+      result = PyBool_FromLong(value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_STRING: {
+      std::string scratch;
+      const std::string& value =
+          reflection->GetStringReference(*message, field_descriptor, &scratch);
+      result = ToStringObject(field_descriptor, value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_ENUM: {
+      const EnumValueDescriptor* enum_value =
+          message->GetReflection()->GetEnum(*message, field_descriptor);
+      result = PyLong_FromLong(enum_value->number());
+      break;
+    }
+    default:
+      PyErr_Format(
+          PyExc_SystemError, "Getting a value from a field of unknown type %d",
+          field_descriptor->cpp_type());
+  }
+
+  return result;
+}
+
+CMessage* InternalGetSubMessage(
+    CMessage* self, const FieldDescriptor* field_descriptor) {
+  const Reflection* reflection = self->message->GetReflection();
+  PyMessageFactory* factory = GetFactoryForMessage(self);
+
+  CMessageClass* message_class = message_factory::GetOrCreateMessageClass(
+      factory, field_descriptor->message_type());
+  ScopedPyObjectPtr message_class_owner(
+      reinterpret_cast<PyObject*>(message_class));
+  if (message_class == nullptr) {
+    return nullptr;
+  }
+
+  CMessage* cmsg = cmessage::NewEmptyMessage(message_class);
+  if (cmsg == nullptr) {
+    return nullptr;
+  }
+
+  Py_INCREF(self);
+  cmsg->parent = self;
+  cmsg->parent_field_descriptor = field_descriptor;
+  if (reflection->HasField(*self->message, field_descriptor)) {
+    // Force triggering MutableMessage to set the lazy message 'Dirty'
+    if (MessageReflectionFriend::IsLazyField(reflection, *self->message,
+                                             field_descriptor)) {
+      Message* sub_message = reflection->MutableMessage(
+          self->message, field_descriptor, factory->message_factory);
+      cmsg->read_only = false;
+      cmsg->message = sub_message;
+      return cmsg;
+    }
+  } else {
+    cmsg->read_only = true;
+  }
+  const Message& sub_message = reflection->GetMessage(
+      *self->message, field_descriptor, factory->message_factory);
+  cmsg->message = const_cast<Message*>(&sub_message);
+  return cmsg;
+}
+
+int InternalSetNonOneofScalar(
+    Message* message,
+    const FieldDescriptor* field_descriptor,
+    PyObject* arg) {
+  const Reflection* reflection = message->GetReflection();
+
+  if (!CheckFieldBelongsToMessage(field_descriptor, message)) {
+    return -1;
+  }
+
+  switch (field_descriptor->cpp_type()) {
+    case FieldDescriptor::CPPTYPE_INT32: {
+      GOOGLE_CHECK_GET_INT32(arg, value, -1);
+      reflection->SetInt32(message, field_descriptor, value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_INT64: {
+      GOOGLE_CHECK_GET_INT64(arg, value, -1);
+      reflection->SetInt64(message, field_descriptor, value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_UINT32: {
+      GOOGLE_CHECK_GET_UINT32(arg, value, -1);
+      reflection->SetUInt32(message, field_descriptor, value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_UINT64: {
+      GOOGLE_CHECK_GET_UINT64(arg, value, -1);
+      reflection->SetUInt64(message, field_descriptor, value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_FLOAT: {
+      GOOGLE_CHECK_GET_FLOAT(arg, value, -1);
+      reflection->SetFloat(message, field_descriptor, value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_DOUBLE: {
+      GOOGLE_CHECK_GET_DOUBLE(arg, value, -1);
+      reflection->SetDouble(message, field_descriptor, value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_BOOL: {
+      GOOGLE_CHECK_GET_BOOL(arg, value, -1);
+      reflection->SetBool(message, field_descriptor, value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_STRING: {
+      if (!CheckAndSetString(
+          arg, message, field_descriptor, reflection, false, -1)) {
+        return -1;
+      }
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_ENUM: {
+      GOOGLE_CHECK_GET_INT32(arg, value, -1);
+      if (reflection->SupportsUnknownEnumValues()) {
+        reflection->SetEnumValue(message, field_descriptor, value);
+      } else {
+        const EnumDescriptor* enum_descriptor = field_descriptor->enum_type();
+        const EnumValueDescriptor* enum_value =
+            enum_descriptor->FindValueByNumber(value);
+        if (enum_value != nullptr) {
+          reflection->SetEnum(message, field_descriptor, enum_value);
+        } else {
+          PyErr_Format(PyExc_ValueError, "Unknown enum value: %d", value);
+          return -1;
+        }
+      }
+      break;
+    }
+    default:
+      PyErr_Format(
+          PyExc_SystemError, "Setting value to a field of unknown type %d",
+          field_descriptor->cpp_type());
+      return -1;
+  }
+
+  return 0;
+}
+
+int InternalSetScalar(
+    CMessage* self,
+    const FieldDescriptor* field_descriptor,
+    PyObject* arg) {
+  if (!CheckFieldBelongsToMessage(field_descriptor, self->message)) {
+    return -1;
+  }
+
+  if (MaybeReleaseOverlappingOneofField(self, field_descriptor) < 0) {
+    return -1;
+  }
+
+  return InternalSetNonOneofScalar(self->message, field_descriptor, arg);
+}
+
+PyObject* FromString(PyTypeObject* cls, PyObject* serialized) {
+  PyObject* py_cmsg =
+      PyObject_CallObject(reinterpret_cast<PyObject*>(cls), nullptr);
+  if (py_cmsg == nullptr) {
+    return nullptr;
+  }
+  CMessage* cmsg = reinterpret_cast<CMessage*>(py_cmsg);
+
+  ScopedPyObjectPtr py_length(MergeFromString(cmsg, serialized));
+  if (py_length == nullptr) {
+    Py_DECREF(py_cmsg);
+    return nullptr;
+  }
+
+  return py_cmsg;
+}
+
+PyObject* DeepCopy(CMessage* self, PyObject* arg) {
+  PyObject* clone =
+      PyObject_CallObject(reinterpret_cast<PyObject*>(Py_TYPE(self)), nullptr);
+  if (clone == nullptr) {
+    return nullptr;
+  }
+  if (!PyObject_TypeCheck(clone, CMessage_Type)) {
+    Py_DECREF(clone);
+    return nullptr;
+  }
+  if (ScopedPyObjectPtr(MergeFrom(reinterpret_cast<CMessage*>(clone),
+                                  reinterpret_cast<PyObject*>(self))) ==
+      nullptr) {
+    Py_DECREF(clone);
+    return nullptr;
+  }
+  return clone;
+}
+
+PyObject* ToUnicode(CMessage* self) {
+  // Lazy import to prevent circular dependencies
+  ScopedPyObjectPtr text_format(
+      PyImport_ImportModule("google.protobuf.text_format"));
+  if (text_format == nullptr) {
+    return nullptr;
+  }
+  ScopedPyObjectPtr method_name(PyUnicode_FromString("MessageToString"));
+  if (method_name == nullptr) {
+    return nullptr;
+  }
+  Py_INCREF(Py_True);
+  ScopedPyObjectPtr encoded(PyObject_CallMethodObjArgs(
+      text_format.get(), method_name.get(), self, Py_True, nullptr));
+  Py_DECREF(Py_True);
+  if (encoded == nullptr) {
+    return nullptr;
+  }
+  PyObject* decoded =
+      PyUnicode_FromEncodedObject(encoded.get(), "utf-8", nullptr);
+  if (decoded == nullptr) {
+    return nullptr;
+  }
+  return decoded;
+}
+
+// CMessage static methods:
+PyObject* _CheckCalledFromGeneratedFile(PyObject* unused,
+                                        PyObject* unused_arg) {
+  if (!_CalledFromGeneratedFile(1)) {
+    PyErr_SetString(PyExc_TypeError,
+                    "Descriptors should not be created directly, "
+                    "but only retrieved from their parent.");
+    return nullptr;
+  }
+  Py_RETURN_NONE;
+}
+
+static PyObject* GetExtensionDict(CMessage* self, void *closure) {
+  // If there are extension_ranges, the message is "extendable". Allocate a
+  // dictionary to store the extension fields.
+  const Descriptor* descriptor = GetMessageDescriptor(Py_TYPE(self));
+  if (!descriptor->extension_range_count()) {
+    PyErr_SetNone(PyExc_AttributeError);
+    return nullptr;
+  }
+  if (!self->composite_fields) {
+    self->composite_fields = new CMessage::CompositeFieldsMap();
+  }
+  if (!self->composite_fields) {
+    return nullptr;
+  }
+  ExtensionDict* extension_dict = extension_dict::NewExtensionDict(self);
+  return reinterpret_cast<PyObject*>(extension_dict);
+}
+
+static PyObject* UnknownFieldSet(CMessage* self) {
+  if (self->unknown_field_set == nullptr) {
+    self->unknown_field_set = unknown_fields::NewPyUnknownFields(self);
+  } else {
+    Py_INCREF(self->unknown_field_set);
+  }
+  return self->unknown_field_set;
+}
+
+static PyObject* GetExtensionsByName(CMessage *self, void *closure) {
+  return message_meta::GetExtensionsByName(
+      reinterpret_cast<CMessageClass*>(Py_TYPE(self)), closure);
+}
+
+static PyObject* GetExtensionsByNumber(CMessage *self, void *closure) {
+  return message_meta::GetExtensionsByNumber(
+      reinterpret_cast<CMessageClass*>(Py_TYPE(self)), closure);
+}
+
+static PyGetSetDef Getters[] = {
+    {"Extensions", (getter)GetExtensionDict, nullptr, "Extension dict"},
+    {"_extensions_by_name", (getter)GetExtensionsByName, nullptr},
+    {"_extensions_by_number", (getter)GetExtensionsByNumber, nullptr},
+    {nullptr},
+};
+
+static PyMethodDef Methods[] = {
+    {"__deepcopy__", (PyCFunction)DeepCopy, METH_VARARGS,
+     "Makes a deep copy of the class."},
+    {"__unicode__", (PyCFunction)ToUnicode, METH_NOARGS,
+     "Outputs a unicode representation of the message."},
+    {"ByteSize", (PyCFunction)ByteSize, METH_NOARGS,
+     "Returns the size of the message in bytes."},
+    {"Clear", (PyCFunction)Clear, METH_NOARGS, "Clears the message."},
+    {"ClearExtension", (PyCFunction)ClearExtension, METH_O,
+     "Clears a message field."},
+    {"ClearField", (PyCFunction)ClearField, METH_O, "Clears a message field."},
+    {"CopyFrom", (PyCFunction)CopyFrom, METH_O,
+     "Copies a protocol message into the current message."},
+    {"DiscardUnknownFields", (PyCFunction)DiscardUnknownFields, METH_NOARGS,
+     "Discards the unknown fields."},
+    {"FindInitializationErrors", (PyCFunction)FindInitializationErrors,
+     METH_NOARGS, "Finds unset required fields."},
+    {"FromString", (PyCFunction)FromString, METH_O | METH_CLASS,
+     "Creates new method instance from given serialized data."},
+    {"HasExtension", (PyCFunction)HasExtension, METH_O,
+     "Checks if a message field is set."},
+    {"HasField", (PyCFunction)HasField, METH_O,
+     "Checks if a message field is set."},
+    {"IsInitialized", (PyCFunction)IsInitialized, METH_VARARGS,
+     "Checks if all required fields of a protocol message are set."},
+    {"ListFields", (PyCFunction)ListFields, METH_NOARGS,
+     "Lists all set fields of a message."},
+    {"MergeFrom", (PyCFunction)MergeFrom, METH_O,
+     "Merges a protocol message into the current message."},
+    {"MergeFromString", (PyCFunction)MergeFromString, METH_O,
+     "Merges a serialized message into the current message."},
+    {"ParseFromString", (PyCFunction)ParseFromString, METH_O,
+     "Parses a serialized message into the current message."},
+    {"RegisterExtension", (PyCFunction)RegisterExtension, METH_O | METH_CLASS,
+     "Registers an extension with the current message."},
+    {"SerializePartialToString", (PyCFunction)SerializePartialToString,
+     METH_VARARGS | METH_KEYWORDS,
+     "Serializes the message to a string, even if it isn't initialized."},
+    {"SerializeToString", (PyCFunction)SerializeToString,
+     METH_VARARGS | METH_KEYWORDS,
+     "Serializes the message to a string, only for initialized messages."},
+    {"SetInParent", (PyCFunction)SetInParent, METH_NOARGS,
+     "Sets the has bit of the given field in its parent message."},
+    {"UnknownFields", (PyCFunction)UnknownFieldSet, METH_NOARGS,
+     "Parse unknown field set"},
+    {"WhichOneof", (PyCFunction)WhichOneof, METH_O,
+     "Returns the name of the field set inside a oneof, "
+     "or None if no field is set."},
+
+    // Static Methods.
+    {"_CheckCalledFromGeneratedFile",
+     (PyCFunction)_CheckCalledFromGeneratedFile, METH_NOARGS | METH_STATIC,
+     "Raises TypeError if the caller is not in a _pb2.py file."},
+    {nullptr, nullptr}};
+
+bool SetCompositeField(CMessage* self, const FieldDescriptor* field,
+                       ContainerBase* value) {
+  if (self->composite_fields == nullptr) {
+    self->composite_fields = new CMessage::CompositeFieldsMap();
+  }
+  (*self->composite_fields)[field] = value;
+  return true;
+}
+
+bool SetSubmessage(CMessage* self, CMessage* submessage) {
+  if (self->child_submessages == nullptr) {
+    self->child_submessages = new CMessage::SubMessagesMap();
+  }
+  (*self->child_submessages)[submessage->message] = submessage;
+  return true;
+}
+
+PyObject* GetAttr(PyObject* pself, PyObject* name) {
+  CMessage* self = reinterpret_cast<CMessage*>(pself);
+  PyObject* result = PyObject_GenericGetAttr(
+      reinterpret_cast<PyObject*>(self), name);
+  if (result != nullptr) {
+    return result;
+  }
+  if (!PyErr_ExceptionMatches(PyExc_AttributeError)) {
+    return nullptr;
+  }
+
+  PyErr_Clear();
+  return message_meta::GetClassAttribute(
+      CheckMessageClass(Py_TYPE(self)), name);
+}
+
+PyObject* GetFieldValue(CMessage* self,
+                        const FieldDescriptor* field_descriptor) {
+  if (self->composite_fields) {
+    CMessage::CompositeFieldsMap::iterator it =
+        self->composite_fields->find(field_descriptor);
+    if (it != self->composite_fields->end()) {
+      ContainerBase* value = it->second;
+      Py_INCREF(value);
+      return value->AsPyObject();
+    }
+  }
+
+  if (self->message->GetDescriptor() != field_descriptor->containing_type()) {
+    PyErr_Format(PyExc_TypeError,
+                 "descriptor to field '%s' doesn't apply to '%s' object",
+                 field_descriptor->full_name().c_str(),
+                 Py_TYPE(self)->tp_name);
+    return nullptr;
+  }
+
+  if (!field_descriptor->is_repeated() &&
+      field_descriptor->cpp_type() != FieldDescriptor::CPPTYPE_MESSAGE) {
+    return InternalGetScalar(self->message, field_descriptor);
+  }
+
+  ContainerBase* py_container = nullptr;
+  if (field_descriptor->is_map()) {
+    const Descriptor* entry_type = field_descriptor->message_type();
+    const FieldDescriptor* value_type = entry_type->map_value();
+    if (value_type->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
+      CMessageClass* value_class = message_factory::GetMessageClass(
+          GetFactoryForMessage(self), value_type->message_type());
+      if (value_class == nullptr) {
+        return nullptr;
+      }
+      py_container =
+          NewMessageMapContainer(self, field_descriptor, value_class);
+    } else {
+      py_container = NewScalarMapContainer(self, field_descriptor);
+    }
+  } else if (field_descriptor->is_repeated()) {
+    if (field_descriptor->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
+      CMessageClass* message_class = message_factory::GetMessageClass(
+          GetFactoryForMessage(self), field_descriptor->message_type());
+      if (message_class == nullptr) {
+        return nullptr;
+      }
+      py_container = repeated_composite_container::NewContainer(
+          self, field_descriptor, message_class);
+    } else {
+      py_container =
+          repeated_scalar_container::NewContainer(self, field_descriptor);
+    }
+  } else if (field_descriptor->cpp_type() ==
+             FieldDescriptor::CPPTYPE_MESSAGE) {
+    py_container = InternalGetSubMessage(self, field_descriptor);
+  } else {
+    PyErr_SetString(PyExc_SystemError, "Should never happen");
+  }
+
+  if (py_container == nullptr) {
+    return nullptr;
+  }
+  if (!SetCompositeField(self, field_descriptor, py_container)) {
+    Py_DECREF(py_container);
+    return nullptr;
+  }
+  return py_container->AsPyObject();
+}
+
+int SetFieldValue(CMessage* self, const FieldDescriptor* field_descriptor,
+                  PyObject* value) {
+  if (self->message->GetDescriptor() != field_descriptor->containing_type()) {
+    PyErr_Format(PyExc_TypeError,
+                 "descriptor to field '%s' doesn't apply to '%s' object",
+                 field_descriptor->full_name().c_str(),
+                 Py_TYPE(self)->tp_name);
+    return -1;
+  } else if (field_descriptor->label() == FieldDescriptor::LABEL_REPEATED) {
+    PyErr_Format(PyExc_AttributeError,
+                 "Assignment not allowed to repeated "
+                 "field \"%s\" in protocol message object.",
+                 field_descriptor->name().c_str());
+    return -1;
+  } else if (field_descriptor->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
+    PyErr_Format(PyExc_AttributeError,
+                 "Assignment not allowed to "
+                 "field \"%s\" in protocol message object.",
+                 field_descriptor->name().c_str());
+    return -1;
+  } else {
+    AssureWritable(self);
+    return InternalSetScalar(self, field_descriptor, value);
+  }
+}
+
+}  // namespace cmessage
+
+// All containers which are not messages:
+// - Make a new parent message
+// - Copy the field
+// - return the field.
+PyObject* ContainerBase::DeepCopy() {
+  CMessage* new_parent =
+      cmessage::NewEmptyMessage(this->parent->GetMessageClass());
+  new_parent->message = this->parent->message->New(nullptr);
+
+  // Copy the map field into the new message.
+  this->parent->message->GetReflection()->SwapFields(
+      this->parent->message, new_parent->message,
+      {this->parent_field_descriptor});
+  this->parent->message->MergeFrom(*new_parent->message);
+
+  PyObject* result =
+      cmessage::GetFieldValue(new_parent, this->parent_field_descriptor);
+  Py_DECREF(new_parent);
+  return result;
+}
+
+void ContainerBase::RemoveFromParentCache() {
+  CMessage* parent = this->parent;
+  if (parent) {
+    if (parent->composite_fields)
+      parent->composite_fields->erase(this->parent_field_descriptor);
+    Py_CLEAR(parent);
+  }
+}
+
+CMessage* CMessage::BuildSubMessageFromPointer(
+    const FieldDescriptor* field_descriptor, Message* sub_message,
+    CMessageClass* message_class) {
+  if (!this->child_submessages) {
+    this->child_submessages = new CMessage::SubMessagesMap();
+  }
+  CMessage* cmsg = FindPtrOrNull(
+      *this->child_submessages, sub_message);
+  if (cmsg) {
+    Py_INCREF(cmsg);
+  } else {
+    cmsg = cmessage::NewEmptyMessage(message_class);
+
+    if (cmsg == nullptr) {
+      return nullptr;
+    }
+    cmsg->message = sub_message;
+    Py_INCREF(this);
+    cmsg->parent = this;
+    cmsg->parent_field_descriptor = field_descriptor;
+    cmessage::SetSubmessage(this, cmsg);
+  }
+  return cmsg;
+}
+
+CMessage* CMessage::MaybeReleaseSubMessage(Message* sub_message) {
+  if (!this->child_submessages) {
+    return nullptr;
+  }
+  CMessage* released = FindPtrOrNull(
+      *this->child_submessages, sub_message);
+  if (!released) {
+    return nullptr;
+  }
+  // The target message will now own its content.
+  Py_CLEAR(released->parent);
+  released->parent_field_descriptor = nullptr;
+  released->read_only = false;
+  // Delete it from the cache.
+  this->child_submessages->erase(sub_message);
+  return released;
+}
+
+static CMessageClass _CMessage_Type = {{{
+    PyVarObject_HEAD_INIT(&_CMessageClass_Type, 0) FULL_MODULE_NAME
+    ".CMessage",                    // tp_name
+    sizeof(CMessage),               // tp_basicsize
+    0,                              //  tp_itemsize
+    (destructor)cmessage::Dealloc,  //  tp_dealloc
+#if PY_VERSION_HEX < 0x03080000
+    nullptr,  // tp_print
+#else
+    0,  // tp_vectorcall_offset
+#endif
+    nullptr,                      //  tp_getattr
+    nullptr,                      //  tp_setattr
+    nullptr,                      //  tp_compare
+    (reprfunc)cmessage::ToStr,    //  tp_repr
+    nullptr,                      //  tp_as_number
+    nullptr,                      //  tp_as_sequence
+    nullptr,                      //  tp_as_mapping
+    PyObject_HashNotImplemented,  //  tp_hash
+    nullptr,                      //  tp_call
+    (reprfunc)cmessage::ToStr,    //  tp_str
+    cmessage::GetAttr,            //  tp_getattro
+    nullptr,                      //  tp_setattro
+    nullptr,                      //  tp_as_buffer
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE |
+        Py_TPFLAGS_HAVE_VERSION_TAG,     //  tp_flags
+    "A ProtocolMessage",                 //  tp_doc
+    nullptr,                             //  tp_traverse
+    nullptr,                             //  tp_clear
+    (richcmpfunc)cmessage::RichCompare,  //  tp_richcompare
+    offsetof(CMessage, weakreflist),     //  tp_weaklistoffset
+    nullptr,                             //  tp_iter
+    nullptr,                             //  tp_iternext
+    cmessage::Methods,                   //  tp_methods
+    nullptr,                             //  tp_members
+    cmessage::Getters,                   //  tp_getset
+    nullptr,                             //  tp_base
+    nullptr,                             //  tp_dict
+    nullptr,                             //  tp_descr_get
+    nullptr,                             //  tp_descr_set
+    0,                                   //  tp_dictoffset
+    (initproc)cmessage::Init,            //  tp_init
+    nullptr,                             //  tp_alloc
+    cmessage::New,                       //  tp_new
+}}};
+PyTypeObject* CMessage_Type = &_CMessage_Type.super.ht_type;
+
+// --- Exposing the C proto living inside Python proto to C code:
+
+const Message* (*GetCProtoInsidePyProtoPtr)(PyObject* msg);
+Message* (*MutableCProtoInsidePyProtoPtr)(PyObject* msg);
+
+static const Message* GetCProtoInsidePyProtoImpl(PyObject* msg) {
+  const Message* message = PyMessage_GetMessagePointer(msg);
+  if (message == nullptr) {
+    PyErr_Clear();
+    return nullptr;
+  }
+  return message;
+}
+
+static Message* MutableCProtoInsidePyProtoImpl(PyObject* msg) {
+  Message* message = PyMessage_GetMutableMessagePointer(msg);
+  if (message == nullptr) {
+    PyErr_Clear();
+    return nullptr;
+  }
+  return message;
+}
+
+const Message* PyMessage_GetMessagePointer(PyObject* msg) {
+  if (!PyObject_TypeCheck(msg, CMessage_Type)) {
+    PyErr_SetString(PyExc_TypeError, "Not a Message instance");
+    return nullptr;
+  }
+  CMessage* cmsg = reinterpret_cast<CMessage*>(msg);
+  return cmsg->message;
+}
+
+Message* PyMessage_GetMutableMessagePointer(PyObject* msg) {
+  if (!PyObject_TypeCheck(msg, CMessage_Type)) {
+    PyErr_SetString(PyExc_TypeError, "Not a Message instance");
+    return nullptr;
+  }
+  CMessage* cmsg = reinterpret_cast<CMessage*>(msg);
+
+
+  if ((cmsg->composite_fields && !cmsg->composite_fields->empty()) ||
+      (cmsg->child_submessages && !cmsg->child_submessages->empty())) {
+    // There is currently no way of accurately syncing arbitrary changes to
+    // the underlying C++ message back to the CMessage (e.g. removed repeated
+    // composite containers). We only allow direct mutation of the underlying
+    // C++ message if there is no child data in the CMessage.
+    PyErr_SetString(PyExc_ValueError,
+                    "Cannot reliably get a mutable pointer "
+                    "to a message with extra references");
+    return nullptr;
+  }
+  cmessage::AssureWritable(cmsg);
+  return cmsg->message;
+}
+
+// Returns a new reference to the MessageClass to use for message creation.
+// - if a PyMessageFactory is passed, use it.
+// - Otherwise, if a PyDescriptorPool was created, use its factory.
+static CMessageClass* GetMessageClassFromDescriptor(
+    const Descriptor* descriptor, PyObject* py_message_factory) {
+  PyMessageFactory* factory = nullptr;
+  if (py_message_factory == nullptr) {
+    PyDescriptorPool* pool =
+        GetDescriptorPool_FromPool(descriptor->file()->pool());
+    if (pool == nullptr) {
+      PyErr_SetString(PyExc_TypeError,
+                      "Unknown descriptor pool; C++ users should call "
+                      "DescriptorPool_FromPool and keep it alive");
+      return nullptr;
+    }
+    factory = pool->py_message_factory;
+  } else if (PyObject_TypeCheck(py_message_factory, &PyMessageFactory_Type)) {
+    factory = reinterpret_cast<PyMessageFactory*>(py_message_factory);
+  } else {
+    PyErr_SetString(PyExc_TypeError, "Expected a MessageFactory");
+    return nullptr;
+  }
+
+  return message_factory::GetOrCreateMessageClass(factory, descriptor);
+}
+
+PyObject* PyMessage_New(const Descriptor* descriptor,
+                        PyObject* py_message_factory) {
+  CMessageClass* message_class =
+      GetMessageClassFromDescriptor(descriptor, py_message_factory);
+  if (message_class == nullptr) {
+    return nullptr;
+  }
+
+  CMessage* self = cmessage::NewCMessage(message_class);
+  Py_DECREF(message_class);
+  if (self == nullptr) {
+    return nullptr;
+  }
+  return self->AsPyObject();
+}
+
+PyObject* PyMessage_NewMessageOwnedExternally(Message* message,
+                                              PyObject* py_message_factory) {
+  CMessageClass* message_class = GetMessageClassFromDescriptor(
+      message->GetDescriptor(), py_message_factory);
+  if (message_class == nullptr) {
+    return nullptr;
+  }
+
+  CMessage* self = cmessage::NewEmptyMessage(message_class);
+  Py_DECREF(message_class);
+  if (self == nullptr) {
+    return nullptr;
+  }
+  self->message = message;
+  Py_INCREF(Py_None);
+  self->parent = reinterpret_cast<CMessage*>(Py_None);
+  return self->AsPyObject();
+}
+
+void InitGlobals() {
+  // TODO(gps): Check all return values in this function for NULL and propagate
+  // the error (MemoryError) on up to result in an import failure.  These should
+  // also be freed and reset to NULL during finalization.
+  kDESCRIPTOR = PyUnicode_FromString("DESCRIPTOR");
+
+  PyObject* dummy_obj = PySet_New(nullptr);
+  kEmptyWeakref = PyWeakref_NewRef(dummy_obj, nullptr);
+  Py_DECREF(dummy_obj);
+}
+
+bool InitProto2MessageModule(PyObject *m) {
+  // Initialize types and globals in descriptor.cc
+  if (!InitDescriptor()) {
+    return false;
+  }
+
+  // Initialize types and globals in descriptor_pool.cc
+  if (!InitDescriptorPool()) {
+    return false;
+  }
+
+  // Initialize types and globals in message_factory.cc
+  if (!InitMessageFactory()) {
+    return false;
+  }
+
+  // Initialize constants defined in this file.
+  InitGlobals();
+
+  CMessageClass_Type->tp_base = &PyType_Type;
+  if (PyType_Ready(CMessageClass_Type) < 0) {
+    return false;
+  }
+  PyModule_AddObject(m, "MessageMeta",
+                     reinterpret_cast<PyObject*>(CMessageClass_Type));
+
+  if (PyType_Ready(CMessage_Type) < 0) {
+    return false;
+  }
+  if (PyType_Ready(CFieldProperty_Type) < 0) {
+    return false;
+  }
+
+  // DESCRIPTOR is set on each protocol buffer message class elsewhere, but set
+  // it here as well to document that subclasses need to set it.
+  PyDict_SetItem(CMessage_Type->tp_dict, kDESCRIPTOR, Py_None);
+  // Invalidate any cached data for the CMessage type.
+  // This call is necessary to correctly support Py_TPFLAGS_HAVE_VERSION_TAG,
+  // after we have modified CMessage_Type.tp_dict.
+  PyType_Modified(CMessage_Type);
+
+  PyModule_AddObject(m, "Message", reinterpret_cast<PyObject*>(CMessage_Type));
+
+  // Initialize Repeated container types.
+  {
+    if (PyType_Ready(&RepeatedScalarContainer_Type) < 0) {
+      return false;
+    }
+
+    PyModule_AddObject(
+        m, "RepeatedScalarContainer",
+        reinterpret_cast<PyObject*>(&RepeatedScalarContainer_Type));
+
+    if (PyType_Ready(&RepeatedCompositeContainer_Type) < 0) {
+      return false;
+    }
+
+    PyModule_AddObject(
+        m, "RepeatedCompositeContainer",
+        reinterpret_cast<PyObject*>(&RepeatedCompositeContainer_Type));
+
+    // Register them as MutableSequence.
+    ScopedPyObjectPtr collections(PyImport_ImportModule("collections.abc"));
+    if (collections == nullptr) {
+      return false;
+    }
+    ScopedPyObjectPtr mutable_sequence(
+        PyObject_GetAttrString(collections.get(), "MutableSequence"));
+    if (mutable_sequence == nullptr) {
+      return false;
+    }
+    if (ScopedPyObjectPtr(
+            PyObject_CallMethod(mutable_sequence.get(), "register", "O",
+                                &RepeatedScalarContainer_Type)) == nullptr) {
+      return false;
+    }
+    if (ScopedPyObjectPtr(
+            PyObject_CallMethod(mutable_sequence.get(), "register", "O",
+                                &RepeatedCompositeContainer_Type)) == nullptr) {
+      return false;
+    }
+  }
+
+  if (PyType_Ready(&PyUnknownFields_Type) < 0) {
+    return false;
+  }
+
+  PyModule_AddObject(m, "UnknownFieldSet",
+                     reinterpret_cast<PyObject*>(&PyUnknownFields_Type));
+
+  if (PyType_Ready(&PyUnknownFieldRef_Type) < 0) {
+    return false;
+  }
+
+  PyModule_AddObject(m, "UnknownField",
+                     reinterpret_cast<PyObject*>(&PyUnknownFieldRef_Type));
+
+  // Initialize Map container types.
+  if (!InitMapContainers()) {
+    return false;
+  }
+  PyModule_AddObject(m, "ScalarMapContainer",
+                     reinterpret_cast<PyObject*>(ScalarMapContainer_Type));
+  PyModule_AddObject(m, "MessageMapContainer",
+                     reinterpret_cast<PyObject*>(MessageMapContainer_Type));
+  PyModule_AddObject(m, "MapIterator",
+                     reinterpret_cast<PyObject*>(&MapIterator_Type));
+
+  if (PyType_Ready(&ExtensionDict_Type) < 0) {
+    return false;
+  }
+  PyModule_AddObject(m, "ExtensionDict",
+                     reinterpret_cast<PyObject*>(&ExtensionDict_Type));
+  if (PyType_Ready(&ExtensionIterator_Type) < 0) {
+    return false;
+  }
+  PyModule_AddObject(m, "ExtensionIterator",
+                     reinterpret_cast<PyObject*>(&ExtensionIterator_Type));
+
+  // Expose the DescriptorPool used to hold all descriptors added from generated
+  // pb2.py files.
+  // PyModule_AddObject steals a reference.
+  Py_INCREF(GetDefaultDescriptorPool());
+  PyModule_AddObject(m, "default_pool",
+                     reinterpret_cast<PyObject*>(GetDefaultDescriptorPool()));
+
+  PyModule_AddObject(m, "DescriptorPool",
+                     reinterpret_cast<PyObject*>(&PyDescriptorPool_Type));
+  PyModule_AddObject(m, "Descriptor",
+                     reinterpret_cast<PyObject*>(&PyMessageDescriptor_Type));
+  PyModule_AddObject(m, "FieldDescriptor",
+                     reinterpret_cast<PyObject*>(&PyFieldDescriptor_Type));
+  PyModule_AddObject(m, "EnumDescriptor",
+                     reinterpret_cast<PyObject*>(&PyEnumDescriptor_Type));
+  PyModule_AddObject(m, "EnumValueDescriptor",
+                     reinterpret_cast<PyObject*>(&PyEnumValueDescriptor_Type));
+  PyModule_AddObject(m, "FileDescriptor",
+                     reinterpret_cast<PyObject*>(&PyFileDescriptor_Type));
+  PyModule_AddObject(m, "OneofDescriptor",
+                     reinterpret_cast<PyObject*>(&PyOneofDescriptor_Type));
+  PyModule_AddObject(m, "ServiceDescriptor",
+                     reinterpret_cast<PyObject*>(&PyServiceDescriptor_Type));
+  PyModule_AddObject(m, "MethodDescriptor",
+                     reinterpret_cast<PyObject*>(&PyMethodDescriptor_Type));
+
+  PyObject* enum_type_wrapper = PyImport_ImportModule(
+      "google.protobuf.internal.enum_type_wrapper");
+  if (enum_type_wrapper == nullptr) {
+    return false;
+  }
+  EnumTypeWrapper_class =
+      PyObject_GetAttrString(enum_type_wrapper, "EnumTypeWrapper");
+  Py_DECREF(enum_type_wrapper);
+
+  PyObject* message_module = PyImport_ImportModule(
+      "google.protobuf.message");
+  if (message_module == nullptr) {
+    return false;
+  }
+  EncodeError_class = PyObject_GetAttrString(message_module, "EncodeError");
+  DecodeError_class = PyObject_GetAttrString(message_module, "DecodeError");
+  PythonMessage_class = PyObject_GetAttrString(message_module, "Message");
+  Py_DECREF(message_module);
+
+  PyObject* pickle_module = PyImport_ImportModule("pickle");
+  if (pickle_module == nullptr) {
+    return false;
+  }
+  PickleError_class = PyObject_GetAttrString(pickle_module, "PickleError");
+  Py_DECREF(pickle_module);
+
+  // Override {Get,Mutable}CProtoInsidePyProto.
+  GetCProtoInsidePyProtoPtr = GetCProtoInsidePyProtoImpl;
+  MutableCProtoInsidePyProtoPtr = MutableCProtoInsidePyProtoImpl;
+
+  return true;
+}
+
+}  // namespace python
+}  // namespace protobuf
+}  // namespace google
diff --git a/lark_channel/ws/pb/google/protobuf/pyext/message.h b/lark_channel/ws/pb/google/protobuf/pyext/message.h
new file mode 100644
index 0000000..b17daa5
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/pyext/message.h
@@ -0,0 +1,377 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: anuraag@google.com (Anuraag Agrawal)
+// Author: tibell@google.com (Johan Tibell)
+
+#ifndef GOOGLE_PROTOBUF_PYTHON_CPP_MESSAGE_H__
+#define GOOGLE_PROTOBUF_PYTHON_CPP_MESSAGE_H__
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+#include <google/protobuf/stubs/common.h>
+
+namespace google {
+namespace protobuf {
+
+class Message;
+class Reflection;
+class FieldDescriptor;
+class Descriptor;
+class DescriptorPool;
+class MessageFactory;
+
+namespace python {
+
+struct ExtensionDict;
+struct PyMessageFactory;
+struct CMessageClass;
+
+// Most of the complexity of the Message class comes from the "Release"
+// behavior:
+//
+// When a field is cleared, it is only detached from its message. Existing
+// references to submessages, to repeated container etc. won't see any change,
+// as if the data was effectively managed by these containers.
+//
+// ExtensionDicts and UnknownFields containers do NOT follow this rule. They
+// don't store any data, and always refer to their parent message.
+
+struct ContainerBase {
+  PyObject_HEAD;
+
+  // Strong reference to a parent message object. For a CMessage there are three
+  // cases:
+  // - For a top-level message, this pointer is NULL.
+  // - For a sub-message, this points to the parent message.
+  // - For a message managed externally, this is a owned reference to Py_None.
+  //
+  // For all other types: repeated containers, maps, it always point to a
+  // valid parent CMessage.
+  struct CMessage* parent;
+
+  // If this object belongs to a parent message, describes which field it comes
+  // from.
+  // The pointer is owned by the DescriptorPool (which is kept alive
+  // through the message's Python class)
+  const FieldDescriptor* parent_field_descriptor;
+
+  PyObject* AsPyObject() { return reinterpret_cast<PyObject*>(this); }
+
+  // The Three methods below are only used by Repeated containers, and Maps.
+
+  // This implementation works for all containers which have a parent.
+  PyObject* DeepCopy();
+  // Delete this container object from its parent. Does not work for messages.
+  void RemoveFromParentCache();
+};
+
+typedef struct CMessage : public ContainerBase {
+  // Pointer to the C++ Message object for this CMessage.
+  // - If this object has no parent, we own this pointer.
+  // - If this object has a parent message, the parent owns this pointer.
+  Message* message;
+
+  // Indicates this submessage is pointing to a default instance of a message.
+  // Submessages are always first created as read only messages and are then
+  // made writable, at which point this field is set to false.
+  bool read_only;
+
+  // A mapping indexed by field, containing weak references to contained objects
+  // which need to implement the "Release" mechanism:
+  // direct submessages, RepeatedCompositeContainer, RepeatedScalarContainer
+  // and MapContainer.
+  typedef std::unordered_map<const FieldDescriptor*, ContainerBase*>
+      CompositeFieldsMap;
+  CompositeFieldsMap* composite_fields;
+
+  // A mapping containing weak references to indirect child messages, accessed
+  // through containers: repeated messages, and values of message maps.
+  // This avoid the creation of similar maps in each of those containers.
+  typedef std::unordered_map<const Message*, CMessage*> SubMessagesMap;
+  SubMessagesMap* child_submessages;
+
+  // A reference to PyUnknownFields.
+  PyObject* unknown_field_set;
+
+  // Implements the "weakref" protocol for this object.
+  PyObject* weakreflist;
+
+  // Return a *borrowed* reference to the message class.
+  CMessageClass* GetMessageClass() {
+    return reinterpret_cast<CMessageClass*>(Py_TYPE(this));
+  }
+
+  // For container containing messages, return a Python object for the given
+  // pointer to a message.
+  CMessage* BuildSubMessageFromPointer(const FieldDescriptor* field_descriptor,
+                                       Message* sub_message,
+                                       CMessageClass* message_class);
+  CMessage* MaybeReleaseSubMessage(Message* sub_message);
+} CMessage;
+
+// The (meta) type of all Messages classes.
+// It allows us to cache some C++ pointers in the class object itself, they are
+// faster to extract than from the type's dictionary.
+
+struct CMessageClass {
+  // This is how CPython subclasses C structures: the base structure must be
+  // the first member of the object.
+  PyHeapTypeObject super;
+
+  // C++ descriptor of this message.
+  const Descriptor* message_descriptor;
+
+  // Owned reference, used to keep the pointer above alive.
+  // This reference must stay alive until all message pointers are destructed.
+  PyObject* py_message_descriptor;
+
+  // The Python MessageFactory used to create the class. It is needed to resolve
+  // fields descriptors, including extensions fields; its C++ MessageFactory is
+  // used to instantiate submessages.
+  // This reference must stay alive until all message pointers are destructed.
+  PyMessageFactory* py_message_factory;
+
+  PyObject* AsPyObject() {
+    return reinterpret_cast<PyObject*>(this);
+  }
+};
+
+extern PyTypeObject* CMessageClass_Type;
+extern PyTypeObject* CMessage_Type;
+
+namespace cmessage {
+
+// Internal function to create a new empty Message Python object, but with empty
+// pointers to the C++ objects.
+// The caller must fill self->message, self->owner and eventually self->parent.
+CMessage* NewEmptyMessage(CMessageClass* type);
+
+// Retrieves the C++ descriptor of a Python Extension descriptor.
+// On error, return NULL with an exception set.
+const FieldDescriptor* GetExtensionDescriptor(PyObject* extension);
+
+// Initializes a new CMessage instance for a submessage. Only called once per
+// submessage as the result is cached in composite_fields.
+//
+// Corresponds to reflection api method GetMessage.
+CMessage* InternalGetSubMessage(
+    CMessage* self, const FieldDescriptor* field_descriptor);
+
+// Deletes a range of items in a repeated field (following a
+// removal in a RepeatedCompositeContainer).
+//
+// Corresponds to reflection api method RemoveLast.
+int DeleteRepeatedField(CMessage* self,
+                        const FieldDescriptor* field_descriptor,
+                        PyObject* slice);
+
+// Sets the specified scalar value to the message.
+int InternalSetScalar(CMessage* self,
+                      const FieldDescriptor* field_descriptor,
+                      PyObject* value);
+
+// Sets the specified scalar value to the message.  Requires it is not a Oneof.
+int InternalSetNonOneofScalar(Message* message,
+                              const FieldDescriptor* field_descriptor,
+                              PyObject* arg);
+
+// Retrieves the specified scalar value from the message.
+//
+// Returns a new python reference.
+PyObject* InternalGetScalar(const Message* message,
+                            const FieldDescriptor* field_descriptor);
+
+bool SetCompositeField(CMessage* self, const FieldDescriptor* field,
+                       ContainerBase* value);
+
+bool SetSubmessage(CMessage* self, CMessage* submessage);
+
+// Clears the message, removing all contained data. Extension dictionary and
+// submessages are released first if there are remaining external references.
+//
+// Corresponds to message api method Clear.
+PyObject* Clear(CMessage* self);
+
+// Clears the data described by the given descriptor.
+// Returns -1 on error.
+//
+// Corresponds to reflection api method ClearField.
+int ClearFieldByDescriptor(CMessage* self, const FieldDescriptor* descriptor);
+
+// Checks if the message has the field described by the descriptor. Used for
+// extensions (which have no name).
+// Returns 1 if true, 0 if false, and -1 on error.
+//
+// Corresponds to reflection api method HasField
+int HasFieldByDescriptor(CMessage* self,
+                         const FieldDescriptor* field_descriptor);
+
+// Checks if the message has the named field.
+//
+// Corresponds to reflection api method HasField.
+PyObject* HasField(CMessage* self, PyObject* arg);
+
+// Initializes values of fields on a newly constructed message.
+// Note that positional arguments are disallowed: 'args' must be NULL or the
+// empty tuple.
+int InitAttributes(CMessage* self, PyObject* args, PyObject* kwargs);
+
+PyObject* MergeFrom(CMessage* self, PyObject* arg);
+
+// This method does not do anything beyond checking that no other extension
+// has been registered with the same field number on this class.
+PyObject* RegisterExtension(PyObject* cls, PyObject* extension_handle);
+
+// Get a field from a message.
+PyObject* GetFieldValue(CMessage* self,
+                        const FieldDescriptor* field_descriptor);
+// Sets the value of a scalar field in a message.
+// On error, return -1 with an extension set.
+int SetFieldValue(CMessage* self, const FieldDescriptor* field_descriptor,
+                  PyObject* value);
+
+PyObject* FindInitializationErrors(CMessage* self);
+
+int AssureWritable(CMessage* self);
+
+// Returns the message factory for the given message.
+// This is equivalent to message.MESSAGE_FACTORY
+//
+// The returned factory is suitable for finding fields and building submessages,
+// even in the case of extensions.
+// Returns a *borrowed* reference, and never fails because we pass a CMessage.
+PyMessageFactory* GetFactoryForMessage(CMessage* message);
+
+PyObject* SetAllowOversizeProtos(PyObject* m, PyObject* arg);
+
+}  // namespace cmessage
+
+
+/* Is 64bit */
+#define IS_64BIT (SIZEOF_LONG == 8)
+
+#define FIELD_IS_REPEATED(field_descriptor) \
+  ((field_descriptor)->label() == FieldDescriptor::LABEL_REPEATED)
+
+#define GOOGLE_CHECK_GET_INT32(arg, value, err)  \
+  int32_t value;                          \
+  if (!CheckAndGetInteger(arg, &value)) { \
+    return err;                           \
+  }
+
+#define GOOGLE_CHECK_GET_INT64(arg, value, err)  \
+  int64_t value;                          \
+  if (!CheckAndGetInteger(arg, &value)) { \
+    return err;                           \
+  }
+
+#define GOOGLE_CHECK_GET_UINT32(arg, value, err) \
+  uint32_t value;                         \
+  if (!CheckAndGetInteger(arg, &value)) { \
+    return err;                           \
+  }
+
+#define GOOGLE_CHECK_GET_UINT64(arg, value, err) \
+  uint64_t value;                         \
+  if (!CheckAndGetInteger(arg, &value)) { \
+    return err;                           \
+  }
+
+#define GOOGLE_CHECK_GET_FLOAT(arg, value, err) \
+  float value;                           \
+  if (!CheckAndGetFloat(arg, &value)) {  \
+    return err;                          \
+  }
+
+#define GOOGLE_CHECK_GET_DOUBLE(arg, value, err) \
+  double value;                           \
+  if (!CheckAndGetDouble(arg, &value)) {  \
+    return err;                           \
+  }
+
+#define GOOGLE_CHECK_GET_BOOL(arg, value, err) \
+  bool value;                           \
+  if (!CheckAndGetBool(arg, &value)) {  \
+    return err;                         \
+  }
+
+#define FULL_MODULE_NAME "google.protobuf.pyext._message"
+
+void FormatTypeError(PyObject* arg, const char* expected_types);
+template<class T>
+bool CheckAndGetInteger(PyObject* arg, T* value);
+bool CheckAndGetDouble(PyObject* arg, double* value);
+bool CheckAndGetFloat(PyObject* arg, float* value);
+bool CheckAndGetBool(PyObject* arg, bool* value);
+PyObject* CheckString(PyObject* arg, const FieldDescriptor* descriptor);
+bool CheckAndSetString(
+    PyObject* arg, Message* message,
+    const FieldDescriptor* descriptor,
+    const Reflection* reflection,
+    bool append,
+    int index);
+PyObject* ToStringObject(const FieldDescriptor* descriptor,
+                         const std::string& value);
+
+// Check if the passed field descriptor belongs to the given message.
+// If not, return false and set a Python exception (a KeyError)
+bool CheckFieldBelongsToMessage(const FieldDescriptor* field_descriptor,
+                                const Message* message);
+
+extern PyObject* PickleError_class;
+
+PyObject* PyMessage_New(const Descriptor* descriptor,
+                        PyObject* py_message_factory);
+const Message* PyMessage_GetMessagePointer(PyObject* msg);
+Message* PyMessage_GetMutableMessagePointer(PyObject* msg);
+PyObject* PyMessage_NewMessageOwnedExternally(Message* message,
+                                              PyObject* py_message_factory);
+
+bool InitProto2MessageModule(PyObject *m);
+
+// These are referenced by repeated_scalar_container, and must
+// be explicitly instantiated.
+extern template bool CheckAndGetInteger<int32>(PyObject*, int32*);
+extern template bool CheckAndGetInteger<int64>(PyObject*, int64*);
+extern template bool CheckAndGetInteger<uint32>(PyObject*, uint32*);
+extern template bool CheckAndGetInteger<uint64>(PyObject*, uint64*);
+
+}  // namespace python
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_PYTHON_CPP_MESSAGE_H__
diff --git a/lark_channel/ws/pb/google/protobuf/pyext/message_factory.cc b/lark_channel/ws/pb/google/protobuf/pyext/message_factory.cc
new file mode 100644
index 0000000..bc44dd4
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/pyext/message_factory.cc
@@ -0,0 +1,306 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include <unordered_map>
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+#include <google/protobuf/dynamic_message.h>
+#include <google/protobuf/pyext/descriptor.h>
+#include <google/protobuf/pyext/message.h>
+#include <google/protobuf/pyext/message_factory.h>
+#include <google/protobuf/pyext/scoped_pyobject_ptr.h>
+
+#define PyString_AsStringAndSize(ob, charpp, sizep)              \
+  (PyUnicode_Check(ob)                                           \
+       ? ((*(charpp) = const_cast<char*>(                        \
+               PyUnicode_AsUTF8AndSize(ob, (sizep)))) == nullptr \
+              ? -1                                               \
+              : 0)                                               \
+       : PyBytes_AsStringAndSize(ob, (charpp), (sizep)))
+
+namespace google {
+namespace protobuf {
+namespace python {
+
+namespace message_factory {
+
+PyMessageFactory* NewMessageFactory(PyTypeObject* type, PyDescriptorPool* pool) {
+  PyMessageFactory* factory = reinterpret_cast<PyMessageFactory*>(
+      PyType_GenericAlloc(type, 0));
+  if (factory == nullptr) {
+    return nullptr;
+  }
+
+  DynamicMessageFactory* message_factory = new DynamicMessageFactory();
+  // This option might be the default some day.
+  message_factory->SetDelegateToGeneratedFactory(true);
+  factory->message_factory = message_factory;
+
+  factory->pool = pool;
+  Py_INCREF(pool);
+
+  factory->classes_by_descriptor = new PyMessageFactory::ClassesByMessageMap();
+
+  return factory;
+}
+
+PyObject* New(PyTypeObject* type, PyObject* args, PyObject* kwargs) {
+  static const char* kwlist[] = {"pool", nullptr};
+  PyObject* pool = nullptr;
+  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O",
+                                   const_cast<char**>(kwlist), &pool)) {
+    return nullptr;
+  }
+  ScopedPyObjectPtr owned_pool;
+  if (pool == nullptr || pool == Py_None) {
+    owned_pool.reset(PyObject_CallFunction(
+        reinterpret_cast<PyObject*>(&PyDescriptorPool_Type), nullptr));
+    if (owned_pool == nullptr) {
+      return nullptr;
+    }
+    pool = owned_pool.get();
+  } else {
+    if (!PyObject_TypeCheck(pool, &PyDescriptorPool_Type)) {
+      PyErr_Format(PyExc_TypeError, "Expected a DescriptorPool, got %s",
+                   pool->ob_type->tp_name);
+      return nullptr;
+    }
+  }
+
+  return reinterpret_cast<PyObject*>(
+      NewMessageFactory(type, reinterpret_cast<PyDescriptorPool*>(pool)));
+}
+
+static void Dealloc(PyObject* pself) {
+  PyMessageFactory* self = reinterpret_cast<PyMessageFactory*>(pself);
+
+  typedef PyMessageFactory::ClassesByMessageMap::iterator iterator;
+  for (iterator it = self->classes_by_descriptor->begin();
+       it != self->classes_by_descriptor->end(); ++it) {
+    Py_CLEAR(it->second);
+  }
+  delete self->classes_by_descriptor;
+  delete self->message_factory;
+  Py_CLEAR(self->pool);
+  Py_TYPE(self)->tp_free(pself);
+}
+
+static int GcTraverse(PyObject* pself, visitproc visit, void* arg) {
+  PyMessageFactory* self = reinterpret_cast<PyMessageFactory*>(pself);
+  Py_VISIT(self->pool);
+  for (const auto& desc_and_class : *self->classes_by_descriptor) {
+    Py_VISIT(desc_and_class.second);
+  }
+  return 0;
+}
+
+static int GcClear(PyObject* pself) {
+  PyMessageFactory* self = reinterpret_cast<PyMessageFactory*>(pself);
+  // Here it's important to not clear self->pool, so that the C++ DescriptorPool
+  // is still alive when self->message_factory is destructed.
+  for (auto& desc_and_class : *self->classes_by_descriptor) {
+    Py_CLEAR(desc_and_class.second);
+  }
+
+  return 0;
+}
+
+// Add a message class to our database.
+int RegisterMessageClass(PyMessageFactory* self,
+                         const Descriptor* message_descriptor,
+                         CMessageClass* message_class) {
+  Py_INCREF(message_class);
+  typedef PyMessageFactory::ClassesByMessageMap::iterator iterator;
+  std::pair<iterator, bool> ret = self->classes_by_descriptor->insert(
+      std::make_pair(message_descriptor, message_class));
+  if (!ret.second) {
+    // Update case: DECREF the previous value.
+    Py_DECREF(ret.first->second);
+    ret.first->second = message_class;
+  }
+  return 0;
+}
+
+CMessageClass* GetOrCreateMessageClass(PyMessageFactory* self,
+                                       const Descriptor* descriptor) {
+  // This is the same implementation as MessageFactory.GetPrototype().
+
+  // Do not create a MessageClass that already exists.
+  std::unordered_map<const Descriptor*, CMessageClass*>::iterator it =
+      self->classes_by_descriptor->find(descriptor);
+  if (it != self->classes_by_descriptor->end()) {
+    Py_INCREF(it->second);
+    return it->second;
+  }
+  ScopedPyObjectPtr py_descriptor(
+      PyMessageDescriptor_FromDescriptor(descriptor));
+  if (py_descriptor == nullptr) {
+    return nullptr;
+  }
+  // Create a new message class.
+  ScopedPyObjectPtr args(Py_BuildValue(
+      "s(){sOsOsO}", descriptor->name().c_str(),
+      "DESCRIPTOR", py_descriptor.get(),
+      "__module__", Py_None,
+      "message_factory", self));
+  if (args == nullptr) {
+    return nullptr;
+  }
+  ScopedPyObjectPtr message_class(PyObject_CallObject(
+      reinterpret_cast<PyObject*>(CMessageClass_Type), args.get()));
+  if (message_class == nullptr) {
+    return nullptr;
+  }
+  // Create messages class for the messages used by the fields, and registers
+  // all extensions for these messages during the recursion.
+  for (int field_idx = 0; field_idx < descriptor->field_count(); field_idx++) {
+    const Descriptor* sub_descriptor =
+        descriptor->field(field_idx)->message_type();
+    // It is null if the field type is not a message.
+    if (sub_descriptor != nullptr) {
+      CMessageClass* result = GetOrCreateMessageClass(self, sub_descriptor);
+      if (result == nullptr) {
+        return nullptr;
+      }
+      Py_DECREF(result);
+    }
+  }
+
+  // Register extensions defined in this message.
+  for (int ext_idx = 0 ; ext_idx < descriptor->extension_count() ; ext_idx++) {
+    const FieldDescriptor* extension = descriptor->extension(ext_idx);
+    ScopedPyObjectPtr py_extended_class(
+        GetOrCreateMessageClass(self, extension->containing_type())
+            ->AsPyObject());
+    if (py_extended_class == nullptr) {
+      return nullptr;
+    }
+    ScopedPyObjectPtr py_extension(PyFieldDescriptor_FromDescriptor(extension));
+    if (py_extension == nullptr) {
+      return nullptr;
+    }
+    ScopedPyObjectPtr result(cmessage::RegisterExtension(
+        py_extended_class.get(), py_extension.get()));
+    if (result == nullptr) {
+      return nullptr;
+    }
+  }
+  return reinterpret_cast<CMessageClass*>(message_class.release());
+}
+
+// Retrieve the message class added to our database.
+CMessageClass* GetMessageClass(PyMessageFactory* self,
+                               const Descriptor* message_descriptor) {
+  typedef PyMessageFactory::ClassesByMessageMap::iterator iterator;
+  iterator ret = self->classes_by_descriptor->find(message_descriptor);
+  if (ret == self->classes_by_descriptor->end()) {
+    PyErr_Format(PyExc_TypeError, "No message class registered for '%s'",
+                 message_descriptor->full_name().c_str());
+    return nullptr;
+  } else {
+    return ret->second;
+  }
+}
+
+static PyMethodDef Methods[] = {
+    {nullptr},
+};
+
+static PyObject* GetPool(PyMessageFactory* self, void* closure) {
+  Py_INCREF(self->pool);
+  return reinterpret_cast<PyObject*>(self->pool);
+}
+
+static PyGetSetDef Getters[] = {
+    {"pool", (getter)GetPool, nullptr, "DescriptorPool"},
+    {nullptr},
+};
+
+}  // namespace message_factory
+
+PyTypeObject PyMessageFactory_Type = {
+    PyVarObject_HEAD_INIT(&PyType_Type, 0) FULL_MODULE_NAME
+    ".MessageFactory",         // tp_name
+    sizeof(PyMessageFactory),  // tp_basicsize
+    0,                         // tp_itemsize
+    message_factory::Dealloc,  // tp_dealloc
+#if PY_VERSION_HEX < 0x03080000
+    nullptr,  // tp_print
+#else
+    0,  // tp_vectorcall_offset
+#endif
+    nullptr,  // tp_getattr
+    nullptr,  // tp_setattr
+    nullptr,  // tp_compare
+    nullptr,  // tp_repr
+    nullptr,  // tp_as_number
+    nullptr,  // tp_as_sequence
+    nullptr,  // tp_as_mapping
+    nullptr,  // tp_hash
+    nullptr,  // tp_call
+    nullptr,  // tp_str
+    nullptr,  // tp_getattro
+    nullptr,  // tp_setattro
+    nullptr,  // tp_as_buffer
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,  // tp_flags
+    "A static Message Factory",                                     // tp_doc
+    message_factory::GcTraverse,  // tp_traverse
+    message_factory::GcClear,     // tp_clear
+    nullptr,                      // tp_richcompare
+    0,                            // tp_weaklistoffset
+    nullptr,                      // tp_iter
+    nullptr,                      // tp_iternext
+    message_factory::Methods,     // tp_methods
+    nullptr,                      // tp_members
+    message_factory::Getters,     // tp_getset
+    nullptr,                      // tp_base
+    nullptr,                      // tp_dict
+    nullptr,                      // tp_descr_get
+    nullptr,                      // tp_descr_set
+    0,                            // tp_dictoffset
+    nullptr,                      // tp_init
+    nullptr,                      // tp_alloc
+    message_factory::New,         // tp_new
+    PyObject_GC_Del,              // tp_free
+};
+
+bool InitMessageFactory() {
+  if (PyType_Ready(&PyMessageFactory_Type) < 0) {
+    return false;
+  }
+
+  return true;
+}
+
+}  // namespace python
+}  // namespace protobuf
+}  // namespace google
diff --git a/lark_channel/ws/pb/google/protobuf/pyext/message_factory.h b/lark_channel/ws/pb/google/protobuf/pyext/message_factory.h
new file mode 100644
index 0000000..7dfe425
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/pyext/message_factory.h
@@ -0,0 +1,104 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_PYTHON_CPP_MESSAGE_FACTORY_H__
+#define GOOGLE_PROTOBUF_PYTHON_CPP_MESSAGE_FACTORY_H__
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+#include <unordered_map>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/pyext/descriptor_pool.h>
+
+namespace google {
+namespace protobuf {
+class MessageFactory;
+
+namespace python {
+
+// The (meta) type of all Messages classes.
+struct CMessageClass;
+
+struct PyMessageFactory {
+  PyObject_HEAD
+
+  // DynamicMessageFactory used to create C++ instances of messages.
+  // This object cache the descriptors that were used, so the DescriptorPool
+  // needs to get rid of it before it can delete itself.
+  //
+  // Note: A C++ MessageFactory is different from the PyMessageFactory.
+  // The C++ one creates messages, when the Python one creates classes.
+  MessageFactory* message_factory;
+
+  // Owned reference to a Python DescriptorPool.
+  // This reference must stay until the message_factory is destructed.
+  PyDescriptorPool* pool;
+
+  // Make our own mapping to retrieve Python classes from C++ descriptors.
+  //
+  // Descriptor pointers stored here are owned by the DescriptorPool above.
+  // Python references to classes are owned by this PyDescriptorPool.
+  typedef std::unordered_map<const Descriptor*, CMessageClass*>
+      ClassesByMessageMap;
+  ClassesByMessageMap* classes_by_descriptor;
+};
+
+extern PyTypeObject PyMessageFactory_Type;
+
+namespace message_factory {
+
+// Creates a new MessageFactory instance.
+PyMessageFactory* NewMessageFactory(PyTypeObject* type, PyDescriptorPool* pool);
+
+// Registers a new Python class for the given message descriptor.
+// On error, returns -1 with a Python exception set.
+int RegisterMessageClass(PyMessageFactory* self,
+                         const Descriptor* message_descriptor,
+                         CMessageClass* message_class);
+// Retrieves the Python class registered with the given message descriptor, or
+// fail with a TypeError. Returns a *borrowed* reference.
+CMessageClass* GetMessageClass(PyMessageFactory* self,
+                               const Descriptor* message_descriptor);
+// Retrieves the Python class registered with the given message descriptor.
+// The class is created if not done yet. Returns a *new* reference.
+CMessageClass* GetOrCreateMessageClass(PyMessageFactory* self,
+                                       const Descriptor* message_descriptor);
+}  // namespace message_factory
+
+// Initialize objects used by this module.
+// On error, returns false with a Python exception set.
+bool InitMessageFactory();
+
+}  // namespace python
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_PYTHON_CPP_MESSAGE_FACTORY_H__
diff --git a/lark_channel/ws/pb/google/protobuf/pyext/message_module.cc b/lark_channel/ws/pb/google/protobuf/pyext/message_module.cc
new file mode 100644
index 0000000..2d3c1d2
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/pyext/message_module.cc
@@ -0,0 +1,134 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+#include <google/protobuf/message_lite.h>
+#include <google/protobuf/pyext/descriptor.h>
+#include <google/protobuf/pyext/descriptor_pool.h>
+#include <google/protobuf/pyext/message.h>
+#include <google/protobuf/pyext/message_factory.h>
+#include <google/protobuf/proto_api.h>
+
+namespace {
+
+// C++ API.  Clients get at this via proto_api.h
+struct ApiImplementation : google::protobuf::python::PyProto_API {
+  const google::protobuf::Message* GetMessagePointer(PyObject* msg) const override {
+    return google::protobuf::python::PyMessage_GetMessagePointer(msg);
+  }
+  google::protobuf::Message* GetMutableMessagePointer(PyObject* msg) const override {
+    return google::protobuf::python::PyMessage_GetMutableMessagePointer(msg);
+  }
+  const google::protobuf::Descriptor* MessageDescriptor_AsDescriptor(
+      PyObject* desc) const override {
+    return google::protobuf::python::PyMessageDescriptor_AsDescriptor(desc);
+  }
+  const google::protobuf::EnumDescriptor* EnumDescriptor_AsDescriptor(
+      PyObject* enum_desc) const override {
+    return google::protobuf::python::PyEnumDescriptor_AsDescriptor(enum_desc);
+  }
+
+  const google::protobuf::DescriptorPool* GetDefaultDescriptorPool() const override {
+    return google::protobuf::python::GetDefaultDescriptorPool()->pool;
+  }
+
+  google::protobuf::MessageFactory* GetDefaultMessageFactory() const override {
+    return google::protobuf::python::GetDefaultDescriptorPool()
+        ->py_message_factory->message_factory;
+  }
+  PyObject* NewMessage(const google::protobuf::Descriptor* descriptor,
+                       PyObject* py_message_factory) const override {
+    return google::protobuf::python::PyMessage_New(descriptor, py_message_factory);
+  }
+  PyObject* NewMessageOwnedExternally(
+      google::protobuf::Message* msg, PyObject* py_message_factory) const override {
+    return google::protobuf::python::PyMessage_NewMessageOwnedExternally(
+        msg, py_message_factory);
+  }
+  PyObject* DescriptorPool_FromPool(
+      const google::protobuf::DescriptorPool* pool) const override {
+    return google::protobuf::python::PyDescriptorPool_FromPool(pool);
+  }
+};
+
+}  // namespace
+
+static const char module_docstring[] =
+    "python-proto2 is a module that can be used to enhance proto2 Python API\n"
+    "performance.\n"
+    "\n"
+    "It provides access to the protocol buffers C++ reflection API that\n"
+    "implements the basic protocol buffer functions.";
+
+static PyMethodDef ModuleMethods[] = {
+    {"SetAllowOversizeProtos",
+     (PyCFunction)google::protobuf::python::cmessage::SetAllowOversizeProtos, METH_O,
+     "Enable/disable oversize proto parsing."},
+    // DO NOT USE: For migration and testing only.
+    {nullptr, nullptr}};
+
+static struct PyModuleDef _module = {PyModuleDef_HEAD_INIT,
+                                     "_message",
+                                     module_docstring,
+                                     -1,
+                                     ModuleMethods, /* m_methods */
+                                     nullptr,
+                                     nullptr,
+                                     nullptr,
+                                     nullptr};
+
+PyMODINIT_FUNC PyInit__message() {
+  PyObject* m;
+  m = PyModule_Create(&_module);
+  if (m == nullptr) {
+    return nullptr;
+  }
+
+  if (!google::protobuf::python::InitProto2MessageModule(m)) {
+    Py_DECREF(m);
+    return nullptr;
+  }
+
+  // Adds the C++ API
+  if (PyObject* api = PyCapsule_New(
+          new ApiImplementation(), google::protobuf::python::PyProtoAPICapsuleName(),
+          [](PyObject* o) {
+            delete (ApiImplementation*)PyCapsule_GetPointer(
+                o, google::protobuf::python::PyProtoAPICapsuleName());
+          })) {
+    PyModule_AddObject(m, "proto_API", api);
+  } else {
+    return nullptr;
+  }
+
+  return m;
+}
diff --git a/lark_channel/ws/pb/google/protobuf/pyext/repeated_composite_container.cc b/lark_channel/ws/pb/google/protobuf/pyext/repeated_composite_container.cc
new file mode 100644
index 0000000..0b63f82
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/pyext/repeated_composite_container.cc
@@ -0,0 +1,591 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: anuraag@google.com (Anuraag Agrawal)
+// Author: tibell@google.com (Johan Tibell)
+
+#include <google/protobuf/pyext/repeated_composite_container.h>
+
+#include <memory>
+
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/dynamic_message.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/reflection.h>
+#include <google/protobuf/pyext/descriptor.h>
+#include <google/protobuf/pyext/descriptor_pool.h>
+#include <google/protobuf/pyext/message.h>
+#include <google/protobuf/pyext/message_factory.h>
+#include <google/protobuf/pyext/scoped_pyobject_ptr.h>
+#include <google/protobuf/stubs/map_util.h>
+
+namespace google {
+namespace protobuf {
+namespace python {
+
+namespace repeated_composite_container {
+
+// ---------------------------------------------------------------------
+// len()
+
+static Py_ssize_t Length(PyObject* pself) {
+  RepeatedCompositeContainer* self =
+      reinterpret_cast<RepeatedCompositeContainer*>(pself);
+
+  Message* message = self->parent->message;
+  return message->GetReflection()->FieldSize(*message,
+                                             self->parent_field_descriptor);
+}
+
+// ---------------------------------------------------------------------
+// add()
+
+PyObject* Add(RepeatedCompositeContainer* self, PyObject* args,
+              PyObject* kwargs) {
+  if (cmessage::AssureWritable(self->parent) == -1) return nullptr;
+  Message* message = self->parent->message;
+
+  Message* sub_message = message->GetReflection()->AddMessage(
+      message, self->parent_field_descriptor,
+      self->child_message_class->py_message_factory->message_factory);
+  CMessage* cmsg = self->parent->BuildSubMessageFromPointer(
+      self->parent_field_descriptor, sub_message, self->child_message_class);
+
+  if (cmessage::InitAttributes(cmsg, args, kwargs) < 0) {
+    message->GetReflection()->RemoveLast(message,
+                                         self->parent_field_descriptor);
+    Py_DECREF(cmsg);
+    return nullptr;
+  }
+
+  return cmsg->AsPyObject();
+}
+
+static PyObject* AddMethod(PyObject* self, PyObject* args, PyObject* kwargs) {
+  return Add(reinterpret_cast<RepeatedCompositeContainer*>(self), args, kwargs);
+}
+
+// ---------------------------------------------------------------------
+// append()
+
+static PyObject* AddMessage(RepeatedCompositeContainer* self, PyObject* value) {
+  cmessage::AssureWritable(self->parent);
+  PyObject* py_cmsg;
+  Message* message = self->parent->message;
+  const Reflection* reflection = message->GetReflection();
+  py_cmsg = Add(self, nullptr, nullptr);
+  if (py_cmsg == nullptr) return nullptr;
+  CMessage* cmsg = reinterpret_cast<CMessage*>(py_cmsg);
+  if (ScopedPyObjectPtr(cmessage::MergeFrom(cmsg, value)) == nullptr) {
+    reflection->RemoveLast(message, self->parent_field_descriptor);
+    Py_DECREF(cmsg);
+    return nullptr;
+  }
+  return py_cmsg;
+}
+
+static PyObject* AppendMethod(PyObject* pself, PyObject* value) {
+  RepeatedCompositeContainer* self =
+      reinterpret_cast<RepeatedCompositeContainer*>(pself);
+  ScopedPyObjectPtr py_cmsg(AddMessage(self, value));
+  if (py_cmsg == nullptr) {
+    return nullptr;
+  }
+
+  Py_RETURN_NONE;
+}
+
+// ---------------------------------------------------------------------
+// insert()
+static PyObject* Insert(PyObject* pself, PyObject* args) {
+  RepeatedCompositeContainer* self =
+      reinterpret_cast<RepeatedCompositeContainer*>(pself);
+
+  Py_ssize_t index;
+  PyObject* value;
+  if (!PyArg_ParseTuple(args, "nO", &index, &value)) {
+    return nullptr;
+  }
+
+  ScopedPyObjectPtr py_cmsg(AddMessage(self, value));
+  if (py_cmsg == nullptr) {
+    return nullptr;
+  }
+
+  // Swap the element to right position.
+  Message* message = self->parent->message;
+  const Reflection* reflection = message->GetReflection();
+  const FieldDescriptor* field_descriptor = self->parent_field_descriptor;
+  Py_ssize_t length = reflection->FieldSize(*message, field_descriptor) - 1;
+  Py_ssize_t end_index = index;
+  if (end_index < 0) end_index += length;
+  if (end_index < 0) end_index = 0;
+  for (Py_ssize_t i = length; i > end_index; i--) {
+    reflection->SwapElements(message, field_descriptor, i, i - 1);
+  }
+
+  Py_RETURN_NONE;
+}
+
+// ---------------------------------------------------------------------
+// extend()
+
+PyObject* Extend(RepeatedCompositeContainer* self, PyObject* value) {
+  cmessage::AssureWritable(self->parent);
+  ScopedPyObjectPtr iter(PyObject_GetIter(value));
+  if (iter == nullptr) {
+    PyErr_SetString(PyExc_TypeError, "Value must be iterable");
+    return nullptr;
+  }
+  ScopedPyObjectPtr next;
+  while ((next.reset(PyIter_Next(iter.get()))) != nullptr) {
+    if (!PyObject_TypeCheck(next.get(), CMessage_Type)) {
+      PyErr_SetString(PyExc_TypeError, "Not a cmessage");
+      return nullptr;
+    }
+    ScopedPyObjectPtr new_message(Add(self, nullptr, nullptr));
+    if (new_message == nullptr) {
+      return nullptr;
+    }
+    CMessage* new_cmessage = reinterpret_cast<CMessage*>(new_message.get());
+    if (ScopedPyObjectPtr(cmessage::MergeFrom(new_cmessage, next.get())) ==
+        nullptr) {
+      return nullptr;
+    }
+  }
+  if (PyErr_Occurred()) {
+    return nullptr;
+  }
+  Py_RETURN_NONE;
+}
+
+static PyObject* ExtendMethod(PyObject* self, PyObject* value) {
+  return Extend(reinterpret_cast<RepeatedCompositeContainer*>(self), value);
+}
+
+PyObject* MergeFrom(RepeatedCompositeContainer* self, PyObject* other) {
+  return Extend(self, other);
+}
+
+static PyObject* MergeFromMethod(PyObject* self, PyObject* other) {
+  return MergeFrom(reinterpret_cast<RepeatedCompositeContainer*>(self), other);
+}
+
+// This function does not check the bounds.
+static PyObject* GetItem(RepeatedCompositeContainer* self, Py_ssize_t index,
+                         Py_ssize_t length = -1) {
+  if (length == -1) {
+    Message* message = self->parent->message;
+    const Reflection* reflection = message->GetReflection();
+    length = reflection->FieldSize(*message, self->parent_field_descriptor);
+  }
+  if (index < 0 || index >= length) {
+    PyErr_Format(PyExc_IndexError, "list index (%zd) out of range", index);
+    return nullptr;
+  }
+  Message* message = self->parent->message;
+  Message* sub_message = message->GetReflection()->MutableRepeatedMessage(
+      message, self->parent_field_descriptor, index);
+  return self->parent
+      ->BuildSubMessageFromPointer(self->parent_field_descriptor, sub_message,
+                                   self->child_message_class)
+      ->AsPyObject();
+}
+
+PyObject* Subscript(RepeatedCompositeContainer* self, PyObject* item) {
+  Message* message = self->parent->message;
+  const Reflection* reflection = message->GetReflection();
+  Py_ssize_t length =
+      reflection->FieldSize(*message, self->parent_field_descriptor);
+
+  if (PyIndex_Check(item)) {
+    Py_ssize_t index;
+    index = PyNumber_AsSsize_t(item, PyExc_IndexError);
+    if (index == -1 && PyErr_Occurred()) return nullptr;
+    if (index < 0) index += length;
+    return GetItem(self, index, length);
+  } else if (PySlice_Check(item)) {
+    Py_ssize_t from, to, step, slicelength, cur, i;
+    PyObject* result;
+
+    if (PySlice_GetIndicesEx(item, length, &from, &to, &step, &slicelength) ==
+        -1) {
+      return nullptr;
+    }
+
+    if (slicelength <= 0) {
+      return PyList_New(0);
+    } else {
+      result = PyList_New(slicelength);
+      if (!result) return nullptr;
+
+      for (cur = from, i = 0; i < slicelength; cur += step, i++) {
+        PyList_SET_ITEM(result, i, GetItem(self, cur, length));
+      }
+
+      return result;
+    }
+  } else {
+    PyErr_Format(PyExc_TypeError, "indices must be integers, not %.200s",
+                 item->ob_type->tp_name);
+    return nullptr;
+  }
+}
+
+static PyObject* SubscriptMethod(PyObject* self, PyObject* slice) {
+  return Subscript(reinterpret_cast<RepeatedCompositeContainer*>(self), slice);
+}
+
+int AssignSubscript(RepeatedCompositeContainer* self, PyObject* slice,
+                    PyObject* value) {
+  if (value != nullptr) {
+    PyErr_SetString(PyExc_TypeError, "does not support assignment");
+    return -1;
+  }
+
+  return cmessage::DeleteRepeatedField(self->parent,
+                                       self->parent_field_descriptor, slice);
+}
+
+static int AssignSubscriptMethod(PyObject* self, PyObject* slice,
+                                 PyObject* value) {
+  return AssignSubscript(reinterpret_cast<RepeatedCompositeContainer*>(self),
+                         slice, value);
+}
+
+static PyObject* Remove(PyObject* pself, PyObject* value) {
+  RepeatedCompositeContainer* self =
+      reinterpret_cast<RepeatedCompositeContainer*>(pself);
+  Py_ssize_t len = Length(reinterpret_cast<PyObject*>(self));
+
+  for (Py_ssize_t i = 0; i < len; i++) {
+    ScopedPyObjectPtr item(GetItem(self, i, len));
+    if (item == nullptr) {
+      return nullptr;
+    }
+    int result = PyObject_RichCompareBool(item.get(), value, Py_EQ);
+    if (result < 0) {
+      return nullptr;
+    }
+    if (result) {
+      ScopedPyObjectPtr py_index(PyLong_FromSsize_t(i));
+      if (AssignSubscript(self, py_index.get(), nullptr) < 0) {
+        return nullptr;
+      }
+      Py_RETURN_NONE;
+    }
+  }
+  PyErr_SetString(PyExc_ValueError, "Item to delete not in list");
+  return nullptr;
+}
+
+static PyObject* RichCompare(PyObject* pself, PyObject* other, int opid) {
+  RepeatedCompositeContainer* self =
+      reinterpret_cast<RepeatedCompositeContainer*>(pself);
+
+  if (!PyObject_TypeCheck(other, &RepeatedCompositeContainer_Type)) {
+    PyErr_SetString(PyExc_TypeError,
+                    "Can only compare repeated composite fields "
+                    "against other repeated composite fields.");
+    return nullptr;
+  }
+  if (opid == Py_EQ || opid == Py_NE) {
+    // TODO(anuraag): Don't make new lists just for this...
+    ScopedPyObjectPtr full_slice(PySlice_New(nullptr, nullptr, nullptr));
+    if (full_slice == nullptr) {
+      return nullptr;
+    }
+    ScopedPyObjectPtr list(Subscript(self, full_slice.get()));
+    if (list == nullptr) {
+      return nullptr;
+    }
+    ScopedPyObjectPtr other_list(
+        Subscript(reinterpret_cast<RepeatedCompositeContainer*>(other),
+                  full_slice.get()));
+    if (other_list == nullptr) {
+      return nullptr;
+    }
+    return PyObject_RichCompare(list.get(), other_list.get(), opid);
+  } else {
+    Py_INCREF(Py_NotImplemented);
+    return Py_NotImplemented;
+  }
+}
+
+static PyObject* ToStr(PyObject* pself) {
+  ScopedPyObjectPtr full_slice(PySlice_New(nullptr, nullptr, nullptr));
+  if (full_slice == nullptr) {
+    return nullptr;
+  }
+  ScopedPyObjectPtr list(Subscript(
+      reinterpret_cast<RepeatedCompositeContainer*>(pself), full_slice.get()));
+  if (list == nullptr) {
+    return nullptr;
+  }
+  return PyObject_Repr(list.get());
+}
+
+// ---------------------------------------------------------------------
+// sort()
+
+static void ReorderAttached(RepeatedCompositeContainer* self,
+                            PyObject* child_list) {
+  Message* message = self->parent->message;
+  const Reflection* reflection = message->GetReflection();
+  const FieldDescriptor* descriptor = self->parent_field_descriptor;
+  const Py_ssize_t length = Length(reinterpret_cast<PyObject*>(self));
+
+  // We need to rearrange things to match python's sort order.
+  for (Py_ssize_t i = 0; i < length; ++i) {
+    reflection->UnsafeArenaReleaseLast(message, descriptor);
+  }
+  for (Py_ssize_t i = 0; i < length; ++i) {
+    Message* child_message =
+        reinterpret_cast<CMessage*>(PyList_GET_ITEM(child_list, i))->message;
+    reflection->UnsafeArenaAddAllocatedMessage(message, descriptor,
+                                               child_message);
+  }
+}
+
+// Returns 0 if successful; returns -1 and sets an exception if
+// unsuccessful.
+static int SortPythonMessages(RepeatedCompositeContainer* self, PyObject* args,
+                              PyObject* kwds) {
+  ScopedPyObjectPtr child_list(
+      PySequence_List(reinterpret_cast<PyObject*>(self)));
+  if (child_list == nullptr) {
+    return -1;
+  }
+  ScopedPyObjectPtr m(PyObject_GetAttrString(child_list.get(), "sort"));
+  if (m == nullptr) return -1;
+  if (ScopedPyObjectPtr(PyObject_Call(m.get(), args, kwds)) == nullptr)
+    return -1;
+  ReorderAttached(self, child_list.get());
+  return 0;
+}
+
+static PyObject* Sort(PyObject* pself, PyObject* args, PyObject* kwds) {
+  RepeatedCompositeContainer* self =
+      reinterpret_cast<RepeatedCompositeContainer*>(pself);
+
+  // Support the old sort_function argument for backwards
+  // compatibility.
+  if (kwds != nullptr) {
+    PyObject* sort_func = PyDict_GetItemString(kwds, "sort_function");
+    if (sort_func != nullptr) {
+      // Must set before deleting as sort_func is a borrowed reference
+      // and kwds might be the only thing keeping it alive.
+      PyDict_SetItemString(kwds, "cmp", sort_func);
+      PyDict_DelItemString(kwds, "sort_function");
+    }
+  }
+
+  if (SortPythonMessages(self, args, kwds) < 0) {
+    return nullptr;
+  }
+  Py_RETURN_NONE;
+}
+
+// ---------------------------------------------------------------------
+// reverse()
+
+// Returns 0 if successful; returns -1 and sets an exception if
+// unsuccessful.
+static int ReversePythonMessages(RepeatedCompositeContainer* self) {
+  ScopedPyObjectPtr child_list(
+      PySequence_List(reinterpret_cast<PyObject*>(self)));
+  if (child_list == nullptr) {
+    return -1;
+  }
+  if (ScopedPyObjectPtr(
+          PyObject_CallMethod(child_list.get(), "reverse", nullptr)) == nullptr)
+    return -1;
+  ReorderAttached(self, child_list.get());
+  return 0;
+}
+
+static PyObject* Reverse(PyObject* pself) {
+  RepeatedCompositeContainer* self =
+      reinterpret_cast<RepeatedCompositeContainer*>(pself);
+
+  if (ReversePythonMessages(self) < 0) {
+    return nullptr;
+  }
+  Py_RETURN_NONE;
+}
+
+// ---------------------------------------------------------------------
+
+static PyObject* Item(PyObject* pself, Py_ssize_t index) {
+  RepeatedCompositeContainer* self =
+      reinterpret_cast<RepeatedCompositeContainer*>(pself);
+  return GetItem(self, index);
+}
+
+static PyObject* Pop(PyObject* pself, PyObject* args) {
+  RepeatedCompositeContainer* self =
+      reinterpret_cast<RepeatedCompositeContainer*>(pself);
+
+  Py_ssize_t index = -1;
+  if (!PyArg_ParseTuple(args, "|n", &index)) {
+    return nullptr;
+  }
+  Py_ssize_t length = Length(pself);
+  if (index < 0) index += length;
+  PyObject* item = GetItem(self, index, length);
+  if (item == nullptr) {
+    return nullptr;
+  }
+  ScopedPyObjectPtr py_index(PyLong_FromSsize_t(index));
+  if (AssignSubscript(self, py_index.get(), nullptr) < 0) {
+    return nullptr;
+  }
+  return item;
+}
+
+PyObject* DeepCopy(PyObject* pself, PyObject* arg) {
+  return reinterpret_cast<RepeatedCompositeContainer*>(pself)->DeepCopy();
+}
+
+// The private constructor of RepeatedCompositeContainer objects.
+RepeatedCompositeContainer* NewContainer(
+    CMessage* parent, const FieldDescriptor* parent_field_descriptor,
+    CMessageClass* child_message_class) {
+  if (!CheckFieldBelongsToMessage(parent_field_descriptor, parent->message)) {
+    return nullptr;
+  }
+
+  RepeatedCompositeContainer* self =
+      reinterpret_cast<RepeatedCompositeContainer*>(
+          PyType_GenericAlloc(&RepeatedCompositeContainer_Type, 0));
+  if (self == nullptr) {
+    return nullptr;
+  }
+
+  Py_INCREF(parent);
+  self->parent = parent;
+  self->parent_field_descriptor = parent_field_descriptor;
+  Py_INCREF(child_message_class);
+  self->child_message_class = child_message_class;
+  return self;
+}
+
+static void Dealloc(PyObject* pself) {
+  RepeatedCompositeContainer* self =
+      reinterpret_cast<RepeatedCompositeContainer*>(pself);
+  self->RemoveFromParentCache();
+  Py_CLEAR(self->child_message_class);
+  Py_TYPE(self)->tp_free(pself);
+}
+
+static PySequenceMethods SqMethods = {
+    Length,  /* sq_length */
+    nullptr, /* sq_concat */
+    nullptr, /* sq_repeat */
+    Item     /* sq_item */
+};
+
+static PyMappingMethods MpMethods = {
+    Length,                /* mp_length */
+    SubscriptMethod,       /* mp_subscript */
+    AssignSubscriptMethod, /* mp_ass_subscript */
+};
+
+static PyMethodDef Methods[] = {
+    {"__deepcopy__", DeepCopy, METH_VARARGS, "Makes a deep copy of the class."},
+    {"add", reinterpret_cast<PyCFunction>(AddMethod),
+     METH_VARARGS | METH_KEYWORDS, "Adds an object to the repeated container."},
+    {"append", AppendMethod, METH_O,
+     "Appends a message to the end of the repeated container."},
+    {"insert", Insert, METH_VARARGS,
+     "Inserts a message before the specified index."},
+    {"extend", ExtendMethod, METH_O, "Adds objects to the repeated container."},
+    {"pop", Pop, METH_VARARGS,
+     "Removes an object from the repeated container and returns it."},
+    {"remove", Remove, METH_O,
+     "Removes an object from the repeated container."},
+    {"sort", reinterpret_cast<PyCFunction>(Sort), METH_VARARGS | METH_KEYWORDS,
+     "Sorts the repeated container."},
+    {"reverse", reinterpret_cast<PyCFunction>(Reverse), METH_NOARGS,
+     "Reverses elements order of the repeated container."},
+    {"MergeFrom", MergeFromMethod, METH_O,
+     "Adds objects to the repeated container."},
+    {nullptr, nullptr}};
+
+}  // namespace repeated_composite_container
+
+PyTypeObject RepeatedCompositeContainer_Type = {
+    PyVarObject_HEAD_INIT(&PyType_Type, 0) FULL_MODULE_NAME
+    ".RepeatedCompositeContainer",          // tp_name
+    sizeof(RepeatedCompositeContainer),     // tp_basicsize
+    0,                                      //  tp_itemsize
+    repeated_composite_container::Dealloc,  //  tp_dealloc
+#if PY_VERSION_HEX >= 0x03080000
+    0,  //  tp_vectorcall_offset
+#else
+    nullptr,  //  tp_print
+#endif
+    nullptr,                                    //  tp_getattr
+    nullptr,                                    //  tp_setattr
+    nullptr,                                    //  tp_compare
+    repeated_composite_container::ToStr,        //  tp_repr
+    nullptr,                                    //  tp_as_number
+    &repeated_composite_container::SqMethods,   //  tp_as_sequence
+    &repeated_composite_container::MpMethods,   //  tp_as_mapping
+    PyObject_HashNotImplemented,                //  tp_hash
+    nullptr,                                    //  tp_call
+    nullptr,                                    //  tp_str
+    nullptr,                                    //  tp_getattro
+    nullptr,                                    //  tp_setattro
+    nullptr,                                    //  tp_as_buffer
+    Py_TPFLAGS_DEFAULT,                         //  tp_flags
+    "A Repeated scalar container",              //  tp_doc
+    nullptr,                                    //  tp_traverse
+    nullptr,                                    //  tp_clear
+    repeated_composite_container::RichCompare,  //  tp_richcompare
+    0,                                          //  tp_weaklistoffset
+    nullptr,                                    //  tp_iter
+    nullptr,                                    //  tp_iternext
+    repeated_composite_container::Methods,      //  tp_methods
+    nullptr,                                    //  tp_members
+    nullptr,                                    //  tp_getset
+    nullptr,                                    //  tp_base
+    nullptr,                                    //  tp_dict
+    nullptr,                                    //  tp_descr_get
+    nullptr,                                    //  tp_descr_set
+    0,                                          //  tp_dictoffset
+    nullptr,                                    //  tp_init
+};
+
+}  // namespace python
+}  // namespace protobuf
+}  // namespace google
diff --git a/lark_channel/ws/pb/google/protobuf/pyext/repeated_composite_container.h b/lark_channel/ws/pb/google/protobuf/pyext/repeated_composite_container.h
new file mode 100644
index 0000000..30536ea
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/pyext/repeated_composite_container.h
@@ -0,0 +1,113 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: anuraag@google.com (Anuraag Agrawal)
+// Author: tibell@google.com (Johan Tibell)
+
+#ifndef GOOGLE_PROTOBUF_PYTHON_CPP_REPEATED_COMPOSITE_CONTAINER_H__
+#define GOOGLE_PROTOBUF_PYTHON_CPP_REPEATED_COMPOSITE_CONTAINER_H__
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <google/protobuf/pyext/message.h>
+
+namespace google {
+namespace protobuf {
+
+class FieldDescriptor;
+class Message;
+
+namespace python {
+
+struct CMessageClass;
+
+// A RepeatedCompositeContainer always has a parent message.
+// The parent message also caches reference to items of the container.
+typedef struct RepeatedCompositeContainer : public ContainerBase {
+  // The type used to create new child messages.
+  CMessageClass* child_message_class;
+} RepeatedCompositeContainer;
+
+extern PyTypeObject RepeatedCompositeContainer_Type;
+
+namespace repeated_composite_container {
+
+// Builds a RepeatedCompositeContainer object, from a parent message and a
+// field descriptor.
+RepeatedCompositeContainer* NewContainer(
+    CMessage* parent,
+    const FieldDescriptor* parent_field_descriptor,
+    CMessageClass *child_message_class);
+
+// Appends a new CMessage to the container and returns it.  The
+// CMessage is initialized using the content of kwargs.
+//
+// Returns a new reference if successful; returns NULL and sets an
+// exception if unsuccessful.
+PyObject* Add(RepeatedCompositeContainer* self,
+              PyObject* args,
+              PyObject* kwargs);
+
+// Appends all the CMessages in the input iterator to the container.
+//
+// Returns None if successful; returns NULL and sets an exception if
+// unsuccessful.
+PyObject* Extend(RepeatedCompositeContainer* self, PyObject* value);
+
+// Appends a new message to the container for each message in the
+// input iterator, merging each data element in. Equivalent to extend.
+//
+// Returns None if successful; returns NULL and sets an exception if
+// unsuccessful.
+PyObject* MergeFrom(RepeatedCompositeContainer* self, PyObject* other);
+
+// Accesses messages in the container.
+//
+// Returns a new reference to the message for an integer parameter.
+// Returns a new reference to a list of messages for a slice.
+PyObject* Subscript(RepeatedCompositeContainer* self, PyObject* slice);
+
+// Deletes items from the container (cannot be used for assignment).
+//
+// Returns 0 on success, -1 on failure.
+int AssignSubscript(RepeatedCompositeContainer* self,
+                    PyObject* slice,
+                    PyObject* value);
+}  // namespace repeated_composite_container
+}  // namespace python
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_PYTHON_CPP_REPEATED_COMPOSITE_CONTAINER_H__
diff --git a/lark_channel/ws/pb/google/protobuf/pyext/repeated_scalar_container.cc b/lark_channel/ws/pb/google/protobuf/pyext/repeated_scalar_container.cc
new file mode 100644
index 0000000..f4a8df2
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/pyext/repeated_scalar_container.cc
@@ -0,0 +1,774 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: anuraag@google.com (Anuraag Agrawal)
+// Author: tibell@google.com (Johan Tibell)
+
+#include <google/protobuf/pyext/repeated_scalar_container.h>
+
+#include <cstdint>
+#include <memory>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/dynamic_message.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/pyext/descriptor.h>
+#include <google/protobuf/pyext/descriptor_pool.h>
+#include <google/protobuf/pyext/message.h>
+#include <google/protobuf/pyext/scoped_pyobject_ptr.h>
+
+#define PyString_AsString(ob) \
+  (PyUnicode_Check(ob) ? PyUnicode_AsUTF8(ob) : PyBytes_AsString(ob))
+
+namespace google {
+namespace protobuf {
+namespace python {
+
+namespace repeated_scalar_container {
+
+static int InternalAssignRepeatedField(RepeatedScalarContainer* self,
+                                       PyObject* list) {
+  Message* message = self->parent->message;
+  message->GetReflection()->ClearField(message, self->parent_field_descriptor);
+  for (Py_ssize_t i = 0; i < PyList_GET_SIZE(list); ++i) {
+    PyObject* value = PyList_GET_ITEM(list, i);
+    if (ScopedPyObjectPtr(Append(self, value)) == nullptr) {
+      return -1;
+    }
+  }
+  return 0;
+}
+
+static Py_ssize_t Len(PyObject* pself) {
+  RepeatedScalarContainer* self =
+      reinterpret_cast<RepeatedScalarContainer*>(pself);
+  Message* message = self->parent->message;
+  return message->GetReflection()->FieldSize(*message,
+                                             self->parent_field_descriptor);
+}
+
+static int AssignItem(PyObject* pself, Py_ssize_t index, PyObject* arg) {
+  RepeatedScalarContainer* self =
+      reinterpret_cast<RepeatedScalarContainer*>(pself);
+
+  cmessage::AssureWritable(self->parent);
+  Message* message = self->parent->message;
+  const FieldDescriptor* field_descriptor = self->parent_field_descriptor;
+
+  const Reflection* reflection = message->GetReflection();
+  int field_size = reflection->FieldSize(*message, field_descriptor);
+  if (index < 0) {
+    index = field_size + index;
+  }
+  if (index < 0 || index >= field_size) {
+    PyErr_Format(PyExc_IndexError, "list assignment index (%d) out of range",
+                 static_cast<int>(index));
+    return -1;
+  }
+
+  if (arg == nullptr) {
+    ScopedPyObjectPtr py_index(PyLong_FromLong(index));
+    return cmessage::DeleteRepeatedField(self->parent, field_descriptor,
+                                         py_index.get());
+  }
+
+  if (PySequence_Check(arg) && !(PyBytes_Check(arg) || PyUnicode_Check(arg))) {
+    PyErr_SetString(PyExc_TypeError, "Value must be scalar");
+    return -1;
+  }
+
+  switch (field_descriptor->cpp_type()) {
+    case FieldDescriptor::CPPTYPE_INT32: {
+      GOOGLE_CHECK_GET_INT32(arg, value, -1);
+      reflection->SetRepeatedInt32(message, field_descriptor, index, value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_INT64: {
+      GOOGLE_CHECK_GET_INT64(arg, value, -1);
+      reflection->SetRepeatedInt64(message, field_descriptor, index, value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_UINT32: {
+      GOOGLE_CHECK_GET_UINT32(arg, value, -1);
+      reflection->SetRepeatedUInt32(message, field_descriptor, index, value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_UINT64: {
+      GOOGLE_CHECK_GET_UINT64(arg, value, -1);
+      reflection->SetRepeatedUInt64(message, field_descriptor, index, value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_FLOAT: {
+      GOOGLE_CHECK_GET_FLOAT(arg, value, -1);
+      reflection->SetRepeatedFloat(message, field_descriptor, index, value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_DOUBLE: {
+      GOOGLE_CHECK_GET_DOUBLE(arg, value, -1);
+      reflection->SetRepeatedDouble(message, field_descriptor, index, value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_BOOL: {
+      GOOGLE_CHECK_GET_BOOL(arg, value, -1);
+      reflection->SetRepeatedBool(message, field_descriptor, index, value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_STRING: {
+      if (!CheckAndSetString(arg, message, field_descriptor, reflection, false,
+                             index)) {
+        return -1;
+      }
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_ENUM: {
+      GOOGLE_CHECK_GET_INT32(arg, value, -1);
+      if (reflection->SupportsUnknownEnumValues()) {
+        reflection->SetRepeatedEnumValue(message, field_descriptor, index,
+                                         value);
+      } else {
+        const EnumDescriptor* enum_descriptor = field_descriptor->enum_type();
+        const EnumValueDescriptor* enum_value =
+            enum_descriptor->FindValueByNumber(value);
+        if (enum_value != nullptr) {
+          reflection->SetRepeatedEnum(message, field_descriptor, index,
+                                      enum_value);
+        } else {
+          ScopedPyObjectPtr s(PyObject_Str(arg));
+          if (s != nullptr) {
+            PyErr_Format(PyExc_ValueError, "Unknown enum value: %s",
+                         PyString_AsString(s.get()));
+          }
+          return -1;
+        }
+      }
+      break;
+    }
+    default:
+      PyErr_Format(PyExc_SystemError,
+                   "Adding value to a field of unknown type %d",
+                   field_descriptor->cpp_type());
+      return -1;
+  }
+  return 0;
+}
+
+static PyObject* Item(PyObject* pself, Py_ssize_t index) {
+  RepeatedScalarContainer* self =
+      reinterpret_cast<RepeatedScalarContainer*>(pself);
+
+  Message* message = self->parent->message;
+  const FieldDescriptor* field_descriptor = self->parent_field_descriptor;
+  const Reflection* reflection = message->GetReflection();
+
+  int field_size = reflection->FieldSize(*message, field_descriptor);
+  if (index < 0) {
+    index = field_size + index;
+  }
+  if (index < 0 || index >= field_size) {
+    PyErr_Format(PyExc_IndexError, "list index (%zd) out of range", index);
+    return nullptr;
+  }
+
+  PyObject* result = nullptr;
+  switch (field_descriptor->cpp_type()) {
+    case FieldDescriptor::CPPTYPE_INT32: {
+      int32_t value =
+          reflection->GetRepeatedInt32(*message, field_descriptor, index);
+      result = PyLong_FromLong(value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_INT64: {
+      int64_t value =
+          reflection->GetRepeatedInt64(*message, field_descriptor, index);
+      result = PyLong_FromLongLong(value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_UINT32: {
+      uint32_t value =
+          reflection->GetRepeatedUInt32(*message, field_descriptor, index);
+      result = PyLong_FromLongLong(value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_UINT64: {
+      uint64_t value =
+          reflection->GetRepeatedUInt64(*message, field_descriptor, index);
+      result = PyLong_FromUnsignedLongLong(value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_FLOAT: {
+      float value =
+          reflection->GetRepeatedFloat(*message, field_descriptor, index);
+      result = PyFloat_FromDouble(value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_DOUBLE: {
+      double value =
+          reflection->GetRepeatedDouble(*message, field_descriptor, index);
+      result = PyFloat_FromDouble(value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_BOOL: {
+      bool value =
+          reflection->GetRepeatedBool(*message, field_descriptor, index);
+      result = PyBool_FromLong(value ? 1 : 0);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_ENUM: {
+      const EnumValueDescriptor* enum_value =
+          message->GetReflection()->GetRepeatedEnum(*message, field_descriptor,
+                                                    index);
+      result = PyLong_FromLong(enum_value->number());
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_STRING: {
+      std::string scratch;
+      const std::string& value = reflection->GetRepeatedStringReference(
+          *message, field_descriptor, index, &scratch);
+      result = ToStringObject(field_descriptor, value);
+      break;
+    }
+    default:
+      PyErr_Format(PyExc_SystemError,
+                   "Getting value from a repeated field of unknown type %d",
+                   field_descriptor->cpp_type());
+  }
+
+  return result;
+}
+
+static PyObject* Subscript(PyObject* pself, PyObject* slice) {
+  Py_ssize_t from;
+  Py_ssize_t to;
+  Py_ssize_t step;
+  Py_ssize_t length;
+  Py_ssize_t slicelength;
+  bool return_list = false;
+  if (PyLong_Check(slice)) {
+    from = to = PyLong_AsLong(slice);
+  } else if (PyIndex_Check(slice)) {
+    from = to = PyNumber_AsSsize_t(slice, PyExc_ValueError);
+    if (from == -1 && PyErr_Occurred()) {
+      return nullptr;
+    }
+  } else if (PySlice_Check(slice)) {
+    length = Len(pself);
+    if (PySlice_GetIndicesEx(slice, length, &from, &to, &step, &slicelength) ==
+        -1) {
+      return nullptr;
+    }
+    return_list = true;
+  } else {
+    PyErr_SetString(PyExc_TypeError, "list indices must be integers");
+    return nullptr;
+  }
+
+  if (!return_list) {
+    return Item(pself, from);
+  }
+
+  PyObject* list = PyList_New(0);
+  if (list == nullptr) {
+    return nullptr;
+  }
+  if (from <= to) {
+    if (step < 0) {
+      return list;
+    }
+    for (Py_ssize_t index = from; index < to; index += step) {
+      if (index < 0 || index >= length) {
+        break;
+      }
+      ScopedPyObjectPtr s(Item(pself, index));
+      PyList_Append(list, s.get());
+    }
+  } else {
+    if (step > 0) {
+      return list;
+    }
+    for (Py_ssize_t index = from; index > to; index += step) {
+      if (index < 0 || index >= length) {
+        break;
+      }
+      ScopedPyObjectPtr s(Item(pself, index));
+      PyList_Append(list, s.get());
+    }
+  }
+  return list;
+}
+
+PyObject* Append(RepeatedScalarContainer* self, PyObject* item) {
+  cmessage::AssureWritable(self->parent);
+  Message* message = self->parent->message;
+  const FieldDescriptor* field_descriptor = self->parent_field_descriptor;
+
+  const Reflection* reflection = message->GetReflection();
+  switch (field_descriptor->cpp_type()) {
+    case FieldDescriptor::CPPTYPE_INT32: {
+      GOOGLE_CHECK_GET_INT32(item, value, nullptr);
+      reflection->AddInt32(message, field_descriptor, value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_INT64: {
+      GOOGLE_CHECK_GET_INT64(item, value, nullptr);
+      reflection->AddInt64(message, field_descriptor, value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_UINT32: {
+      GOOGLE_CHECK_GET_UINT32(item, value, nullptr);
+      reflection->AddUInt32(message, field_descriptor, value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_UINT64: {
+      GOOGLE_CHECK_GET_UINT64(item, value, nullptr);
+      reflection->AddUInt64(message, field_descriptor, value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_FLOAT: {
+      GOOGLE_CHECK_GET_FLOAT(item, value, nullptr);
+      reflection->AddFloat(message, field_descriptor, value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_DOUBLE: {
+      GOOGLE_CHECK_GET_DOUBLE(item, value, nullptr);
+      reflection->AddDouble(message, field_descriptor, value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_BOOL: {
+      GOOGLE_CHECK_GET_BOOL(item, value, nullptr);
+      reflection->AddBool(message, field_descriptor, value);
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_STRING: {
+      if (!CheckAndSetString(item, message, field_descriptor, reflection, true,
+                             -1)) {
+        return nullptr;
+      }
+      break;
+    }
+    case FieldDescriptor::CPPTYPE_ENUM: {
+      GOOGLE_CHECK_GET_INT32(item, value, nullptr);
+      if (reflection->SupportsUnknownEnumValues()) {
+        reflection->AddEnumValue(message, field_descriptor, value);
+      } else {
+        const EnumDescriptor* enum_descriptor = field_descriptor->enum_type();
+        const EnumValueDescriptor* enum_value =
+            enum_descriptor->FindValueByNumber(value);
+        if (enum_value != nullptr) {
+          reflection->AddEnum(message, field_descriptor, enum_value);
+        } else {
+          ScopedPyObjectPtr s(PyObject_Str(item));
+          if (s != nullptr) {
+            PyErr_Format(PyExc_ValueError, "Unknown enum value: %s",
+                         PyString_AsString(s.get()));
+          }
+          return nullptr;
+        }
+      }
+      break;
+    }
+    default:
+      PyErr_Format(PyExc_SystemError,
+                   "Adding value to a field of unknown type %d",
+                   field_descriptor->cpp_type());
+      return nullptr;
+  }
+
+  Py_RETURN_NONE;
+}
+
+static PyObject* AppendMethod(PyObject* self, PyObject* item) {
+  return Append(reinterpret_cast<RepeatedScalarContainer*>(self), item);
+}
+
+static int AssSubscript(PyObject* pself, PyObject* slice, PyObject* value) {
+  RepeatedScalarContainer* self =
+      reinterpret_cast<RepeatedScalarContainer*>(pself);
+
+  Py_ssize_t from;
+  Py_ssize_t to;
+  Py_ssize_t step;
+  Py_ssize_t length;
+  Py_ssize_t slicelength;
+  bool create_list = false;
+
+  cmessage::AssureWritable(self->parent);
+  Message* message = self->parent->message;
+  const FieldDescriptor* field_descriptor = self->parent_field_descriptor;
+
+  if (PyLong_Check(slice)) {
+    from = to = PyLong_AsLong(slice);
+  } else if (PySlice_Check(slice)) {
+    const Reflection* reflection = message->GetReflection();
+    length = reflection->FieldSize(*message, field_descriptor);
+    if (PySlice_GetIndicesEx(slice, length, &from, &to, &step, &slicelength) ==
+        -1) {
+      return -1;
+    }
+    create_list = true;
+  } else {
+    PyErr_SetString(PyExc_TypeError, "list indices must be integers");
+    return -1;
+  }
+
+  if (value == nullptr) {
+    return cmessage::DeleteRepeatedField(self->parent, field_descriptor, slice);
+  }
+
+  if (!create_list) {
+    return AssignItem(pself, from, value);
+  }
+
+  ScopedPyObjectPtr full_slice(PySlice_New(nullptr, nullptr, nullptr));
+  if (full_slice == nullptr) {
+    return -1;
+  }
+  ScopedPyObjectPtr new_list(Subscript(pself, full_slice.get()));
+  if (new_list == nullptr) {
+    return -1;
+  }
+  if (PySequence_SetSlice(new_list.get(), from, to, value) < 0) {
+    return -1;
+  }
+
+  return InternalAssignRepeatedField(self, new_list.get());
+}
+
+PyObject* Extend(RepeatedScalarContainer* self, PyObject* value) {
+  cmessage::AssureWritable(self->parent);
+
+  // TODO(ptucker): Deprecate this behavior. b/18413862
+  if (value == Py_None) {
+    Py_RETURN_NONE;
+  }
+  if ((Py_TYPE(value)->tp_as_sequence == nullptr) && PyObject_Not(value)) {
+    Py_RETURN_NONE;
+  }
+
+  ScopedPyObjectPtr iter(PyObject_GetIter(value));
+  if (iter == nullptr) {
+    PyErr_SetString(PyExc_TypeError, "Value must be iterable");
+    return nullptr;
+  }
+  ScopedPyObjectPtr next;
+  while ((next.reset(PyIter_Next(iter.get()))) != nullptr) {
+    if (ScopedPyObjectPtr(Append(self, next.get())) == nullptr) {
+      return nullptr;
+    }
+  }
+  if (PyErr_Occurred()) {
+    return nullptr;
+  }
+  Py_RETURN_NONE;
+}
+
+static PyObject* Insert(PyObject* pself, PyObject* args) {
+  RepeatedScalarContainer* self =
+      reinterpret_cast<RepeatedScalarContainer*>(pself);
+
+  Py_ssize_t index;
+  PyObject* value;
+  if (!PyArg_ParseTuple(args, "lO", &index, &value)) {
+    return nullptr;
+  }
+  ScopedPyObjectPtr full_slice(PySlice_New(nullptr, nullptr, nullptr));
+  ScopedPyObjectPtr new_list(Subscript(pself, full_slice.get()));
+  if (PyList_Insert(new_list.get(), index, value) < 0) {
+    return nullptr;
+  }
+  int ret = InternalAssignRepeatedField(self, new_list.get());
+  if (ret < 0) {
+    return nullptr;
+  }
+  Py_RETURN_NONE;
+}
+
+static PyObject* Remove(PyObject* pself, PyObject* value) {
+  Py_ssize_t match_index = -1;
+  for (Py_ssize_t i = 0; i < Len(pself); ++i) {
+    ScopedPyObjectPtr elem(Item(pself, i));
+    if (PyObject_RichCompareBool(elem.get(), value, Py_EQ)) {
+      match_index = i;
+      break;
+    }
+  }
+  if (match_index == -1) {
+    PyErr_SetString(PyExc_ValueError, "remove(x): x not in container");
+    return nullptr;
+  }
+  if (AssignItem(pself, match_index, nullptr) < 0) {
+    return nullptr;
+  }
+  Py_RETURN_NONE;
+}
+
+static PyObject* ExtendMethod(PyObject* self, PyObject* value) {
+  return Extend(reinterpret_cast<RepeatedScalarContainer*>(self), value);
+}
+
+static PyObject* RichCompare(PyObject* pself, PyObject* other, int opid) {
+  if (opid != Py_EQ && opid != Py_NE) {
+    Py_INCREF(Py_NotImplemented);
+    return Py_NotImplemented;
+  }
+
+  // Copy the contents of this repeated scalar container, and other if it is
+  // also a repeated scalar container, into Python lists so we can delegate
+  // to the list's compare method.
+
+  ScopedPyObjectPtr full_slice(PySlice_New(nullptr, nullptr, nullptr));
+  if (full_slice == nullptr) {
+    return nullptr;
+  }
+
+  ScopedPyObjectPtr other_list_deleter;
+  if (PyObject_TypeCheck(other, &RepeatedScalarContainer_Type)) {
+    other_list_deleter.reset(Subscript(other, full_slice.get()));
+    other = other_list_deleter.get();
+  }
+
+  ScopedPyObjectPtr list(Subscript(pself, full_slice.get()));
+  if (list == nullptr) {
+    return nullptr;
+  }
+  return PyObject_RichCompare(list.get(), other, opid);
+}
+
+PyObject* Reduce(PyObject* unused_self, PyObject* unused_other) {
+  PyErr_Format(PickleError_class,
+               "can't pickle repeated message fields, convert to list first");
+  return nullptr;
+}
+
+static PyObject* Sort(PyObject* pself, PyObject* args, PyObject* kwds) {
+  // Support the old sort_function argument for backwards
+  // compatibility.
+  if (kwds != nullptr) {
+    PyObject* sort_func = PyDict_GetItemString(kwds, "sort_function");
+    if (sort_func != nullptr) {
+      // Must set before deleting as sort_func is a borrowed reference
+      // and kwds might be the only thing keeping it alive.
+      if (PyDict_SetItemString(kwds, "cmp", sort_func) == -1) return nullptr;
+      if (PyDict_DelItemString(kwds, "sort_function") == -1) return nullptr;
+    }
+  }
+
+  ScopedPyObjectPtr full_slice(PySlice_New(nullptr, nullptr, nullptr));
+  if (full_slice == nullptr) {
+    return nullptr;
+  }
+  ScopedPyObjectPtr list(Subscript(pself, full_slice.get()));
+  if (list == nullptr) {
+    return nullptr;
+  }
+  ScopedPyObjectPtr m(PyObject_GetAttrString(list.get(), "sort"));
+  if (m == nullptr) {
+    return nullptr;
+  }
+  ScopedPyObjectPtr res(PyObject_Call(m.get(), args, kwds));
+  if (res == nullptr) {
+    return nullptr;
+  }
+  int ret = InternalAssignRepeatedField(
+      reinterpret_cast<RepeatedScalarContainer*>(pself), list.get());
+  if (ret < 0) {
+    return nullptr;
+  }
+  Py_RETURN_NONE;
+}
+
+static PyObject* Reverse(PyObject* pself) {
+  ScopedPyObjectPtr full_slice(PySlice_New(nullptr, nullptr, nullptr));
+  if (full_slice == nullptr) {
+    return nullptr;
+  }
+  ScopedPyObjectPtr list(Subscript(pself, full_slice.get()));
+  if (list == nullptr) {
+    return nullptr;
+  }
+  ScopedPyObjectPtr res(PyObject_CallMethod(list.get(), "reverse", nullptr));
+  if (res == nullptr) {
+    return nullptr;
+  }
+  int ret = InternalAssignRepeatedField(
+      reinterpret_cast<RepeatedScalarContainer*>(pself), list.get());
+  if (ret < 0) {
+    return nullptr;
+  }
+  Py_RETURN_NONE;
+}
+
+static PyObject* Pop(PyObject* pself, PyObject* args) {
+  Py_ssize_t index = -1;
+  if (!PyArg_ParseTuple(args, "|n", &index)) {
+    return nullptr;
+  }
+  PyObject* item = Item(pself, index);
+  if (item == nullptr) {
+    PyErr_Format(PyExc_IndexError, "list index (%zd) out of range", index);
+    return nullptr;
+  }
+  if (AssignItem(pself, index, nullptr) < 0) {
+    return nullptr;
+  }
+  return item;
+}
+
+static PyObject* ToStr(PyObject* pself) {
+  ScopedPyObjectPtr full_slice(PySlice_New(nullptr, nullptr, nullptr));
+  if (full_slice == nullptr) {
+    return nullptr;
+  }
+  ScopedPyObjectPtr list(Subscript(pself, full_slice.get()));
+  if (list == nullptr) {
+    return nullptr;
+  }
+  return PyObject_Repr(list.get());
+}
+
+static PyObject* MergeFrom(PyObject* pself, PyObject* arg) {
+  return Extend(reinterpret_cast<RepeatedScalarContainer*>(pself), arg);
+}
+
+// The private constructor of RepeatedScalarContainer objects.
+RepeatedScalarContainer* NewContainer(
+    CMessage* parent, const FieldDescriptor* parent_field_descriptor) {
+  if (!CheckFieldBelongsToMessage(parent_field_descriptor, parent->message)) {
+    return nullptr;
+  }
+
+  RepeatedScalarContainer* self = reinterpret_cast<RepeatedScalarContainer*>(
+      PyType_GenericAlloc(&RepeatedScalarContainer_Type, 0));
+  if (self == nullptr) {
+    return nullptr;
+  }
+
+  Py_INCREF(parent);
+  self->parent = parent;
+  self->parent_field_descriptor = parent_field_descriptor;
+
+  return self;
+}
+
+PyObject* DeepCopy(PyObject* pself, PyObject* arg) {
+  return reinterpret_cast<RepeatedScalarContainer*>(pself)->DeepCopy();
+}
+
+static void Dealloc(PyObject* pself) {
+  reinterpret_cast<RepeatedScalarContainer*>(pself)->RemoveFromParentCache();
+  Py_TYPE(pself)->tp_free(pself);
+}
+
+static PySequenceMethods SqMethods = {
+    Len,       /* sq_length */
+    nullptr,   /* sq_concat */
+    nullptr,   /* sq_repeat */
+    Item,      /* sq_item */
+    nullptr,   /* sq_slice */
+    AssignItem /* sq_ass_item */
+};
+
+static PyMappingMethods MpMethods = {
+    Len,          /* mp_length */
+    Subscript,    /* mp_subscript */
+    AssSubscript, /* mp_ass_subscript */
+};
+
+static PyMethodDef Methods[] = {
+    {"__deepcopy__", DeepCopy, METH_VARARGS, "Makes a deep copy of the class."},
+    {"__reduce__", Reduce, METH_NOARGS,
+     "Outputs picklable representation of the repeated field."},
+    {"append", AppendMethod, METH_O,
+     "Appends an object to the repeated container."},
+    {"extend", ExtendMethod, METH_O,
+     "Appends objects to the repeated container."},
+    {"insert", Insert, METH_VARARGS,
+     "Inserts an object at the specified position in the container."},
+    {"pop", Pop, METH_VARARGS,
+     "Removes an object from the repeated container and returns it."},
+    {"remove", Remove, METH_O,
+     "Removes an object from the repeated container."},
+    {"sort", reinterpret_cast<PyCFunction>(Sort), METH_VARARGS | METH_KEYWORDS,
+     "Sorts the repeated container."},
+    {"reverse", reinterpret_cast<PyCFunction>(Reverse), METH_NOARGS,
+     "Reverses elements order of the repeated container."},
+    {"MergeFrom", static_cast<PyCFunction>(MergeFrom), METH_O,
+     "Merges a repeated container into the current container."},
+    {nullptr, nullptr}};
+
+}  // namespace repeated_scalar_container
+
+PyTypeObject RepeatedScalarContainer_Type = {
+    PyVarObject_HEAD_INIT(&PyType_Type, 0) FULL_MODULE_NAME
+    ".RepeatedScalarContainer",              // tp_name
+    sizeof(RepeatedScalarContainer),         // tp_basicsize
+    0,                                       //  tp_itemsize
+    repeated_scalar_container::Dealloc,      //  tp_dealloc
+#if PY_VERSION_HEX >= 0x03080000
+    0,                                       //  tp_vectorcall_offset
+#else
+    nullptr,                                 //  tp_print
+#endif
+    nullptr,                                 //  tp_getattr
+    nullptr,                                 //  tp_setattr
+    nullptr,                                 //  tp_compare
+    repeated_scalar_container::ToStr,        //  tp_repr
+    nullptr,                                 //  tp_as_number
+    &repeated_scalar_container::SqMethods,   //  tp_as_sequence
+    &repeated_scalar_container::MpMethods,   //  tp_as_mapping
+    PyObject_HashNotImplemented,             //  tp_hash
+    nullptr,                                 //  tp_call
+    nullptr,                                 //  tp_str
+    nullptr,                                 //  tp_getattro
+    nullptr,                                 //  tp_setattro
+    nullptr,                                 //  tp_as_buffer
+    Py_TPFLAGS_DEFAULT,                      //  tp_flags
+    "A Repeated scalar container",           //  tp_doc
+    nullptr,                                 //  tp_traverse
+    nullptr,                                 //  tp_clear
+    repeated_scalar_container::RichCompare,  //  tp_richcompare
+    0,                                       //  tp_weaklistoffset
+    nullptr,                                 //  tp_iter
+    nullptr,                                 //  tp_iternext
+    repeated_scalar_container::Methods,      //  tp_methods
+    nullptr,                                 //  tp_members
+    nullptr,                                 //  tp_getset
+    nullptr,                                 //  tp_base
+    nullptr,                                 //  tp_dict
+    nullptr,                                 //  tp_descr_get
+    nullptr,                                 //  tp_descr_set
+    0,                                       //  tp_dictoffset
+    nullptr,                                 //  tp_init
+};
+
+}  // namespace python
+}  // namespace protobuf
+}  // namespace google
diff --git a/lark_channel/ws/pb/google/protobuf/pyext/repeated_scalar_container.h b/lark_channel/ws/pb/google/protobuf/pyext/repeated_scalar_container.h
new file mode 100644
index 0000000..372b6f0
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/pyext/repeated_scalar_container.h
@@ -0,0 +1,78 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: anuraag@google.com (Anuraag Agrawal)
+// Author: tibell@google.com (Johan Tibell)
+
+#ifndef GOOGLE_PROTOBUF_PYTHON_CPP_REPEATED_SCALAR_CONTAINER_H__
+#define GOOGLE_PROTOBUF_PYTHON_CPP_REPEATED_SCALAR_CONTAINER_H__
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+#include <memory>
+
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/pyext/message.h>
+
+namespace google {
+namespace protobuf {
+namespace python {
+
+typedef struct RepeatedScalarContainer : public ContainerBase {
+} RepeatedScalarContainer;
+
+extern PyTypeObject RepeatedScalarContainer_Type;
+
+namespace repeated_scalar_container {
+
+// Builds a RepeatedScalarContainer object, from a parent message and a
+// field descriptor.
+extern RepeatedScalarContainer* NewContainer(
+    CMessage* parent, const FieldDescriptor* parent_field_descriptor);
+
+// Appends the scalar 'item' to the end of the container 'self'.
+//
+// Returns None if successful; returns NULL and sets an exception if
+// unsuccessful.
+PyObject* Append(RepeatedScalarContainer* self, PyObject* item);
+
+// Appends all the elements in the input iterator to the container.
+//
+// Returns None if successful; returns NULL and sets an exception if
+// unsuccessful.
+PyObject* Extend(RepeatedScalarContainer* self, PyObject* value);
+
+}  // namespace repeated_scalar_container
+}  // namespace python
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_PYTHON_CPP_REPEATED_SCALAR_CONTAINER_H__
diff --git a/lark_channel/ws/pb/google/protobuf/pyext/safe_numerics.h b/lark_channel/ws/pb/google/protobuf/pyext/safe_numerics.h
new file mode 100644
index 0000000..93ae640
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/pyext/safe_numerics.h
@@ -0,0 +1,164 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_PYTHON_CPP_SAFE_NUMERICS_H__
+#define GOOGLE_PROTOBUF_PYTHON_CPP_SAFE_NUMERICS_H__
+// Copied from chromium with only changes to the namespace.
+
+#include <limits>
+
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/stubs/common.h>
+
+namespace google {
+namespace protobuf {
+namespace python {
+
+template <bool SameSize, bool DestLarger,
+          bool DestIsSigned, bool SourceIsSigned>
+struct IsValidNumericCastImpl;
+
+#define BASE_NUMERIC_CAST_CASE_SPECIALIZATION(A, B, C, D, Code) \
+template <> struct IsValidNumericCastImpl<A, B, C, D> { \
+  template <class Source, class DestBounds> static inline bool Test( \
+      Source source, DestBounds min, DestBounds max) { \
+    return Code; \
+  } \
+}
+
+#define BASE_NUMERIC_CAST_CASE_SAME_SIZE(DestSigned, SourceSigned, Code) \
+  BASE_NUMERIC_CAST_CASE_SPECIALIZATION( \
+      true, true, DestSigned, SourceSigned, Code); \
+  BASE_NUMERIC_CAST_CASE_SPECIALIZATION( \
+      true, false, DestSigned, SourceSigned, Code)
+
+#define BASE_NUMERIC_CAST_CASE_SOURCE_LARGER(DestSigned, SourceSigned, Code) \
+  BASE_NUMERIC_CAST_CASE_SPECIALIZATION( \
+      false, false, DestSigned, SourceSigned, Code); \
+
+#define BASE_NUMERIC_CAST_CASE_DEST_LARGER(DestSigned, SourceSigned, Code) \
+  BASE_NUMERIC_CAST_CASE_SPECIALIZATION( \
+      false, true, DestSigned, SourceSigned, Code); \
+
+// The three top level cases are:
+// - Same size
+// - Source larger
+// - Dest larger
+// And for each of those three cases, we handle the 4 different possibilities
+// of signed and unsigned. This gives 12 cases to handle, which we enumerate
+// below.
+//
+// The last argument in each of the macros is the actual comparison code. It
+// has three arguments available, source (the value), and min/max which are
+// the ranges of the destination.
+
+
+// These are the cases where both types have the same size.
+
+// Both signed.
+BASE_NUMERIC_CAST_CASE_SAME_SIZE(true, true, true);
+// Both unsigned.
+BASE_NUMERIC_CAST_CASE_SAME_SIZE(false, false, true);
+// Dest unsigned, Source signed.
+BASE_NUMERIC_CAST_CASE_SAME_SIZE(false, true, source >= 0);
+// Dest signed, Source unsigned.
+// This cast is OK because Dest's max must be less than Source's.
+BASE_NUMERIC_CAST_CASE_SAME_SIZE(true, false,
+                                 source <= static_cast<Source>(max));
+
+
+// These are the cases where Source is larger.
+
+// Both unsigned.
+BASE_NUMERIC_CAST_CASE_SOURCE_LARGER(false, false, source <= max);
+// Both signed.
+BASE_NUMERIC_CAST_CASE_SOURCE_LARGER(true, true,
+                                     source >= min && source <= max);
+// Dest is unsigned, Source is signed.
+BASE_NUMERIC_CAST_CASE_SOURCE_LARGER(false, true,
+                                     source >= 0 && source <= max);
+// Dest is signed, Source is unsigned.
+// This cast is OK because Dest's max must be less than Source's.
+BASE_NUMERIC_CAST_CASE_SOURCE_LARGER(true, false,
+                                     source <= static_cast<Source>(max));
+
+
+// These are the cases where Dest is larger.
+
+// Both unsigned.
+BASE_NUMERIC_CAST_CASE_DEST_LARGER(false, false, true);
+// Both signed.
+BASE_NUMERIC_CAST_CASE_DEST_LARGER(true, true, true);
+// Dest is unsigned, Source is signed.
+BASE_NUMERIC_CAST_CASE_DEST_LARGER(false, true, source >= 0);
+// Dest is signed, Source is unsigned.
+BASE_NUMERIC_CAST_CASE_DEST_LARGER(true, false, true);
+
+#undef BASE_NUMERIC_CAST_CASE_SPECIALIZATION
+#undef BASE_NUMERIC_CAST_CASE_SAME_SIZE
+#undef BASE_NUMERIC_CAST_CASE_SOURCE_LARGER
+#undef BASE_NUMERIC_CAST_CASE_DEST_LARGER
+
+
+// The main test for whether the conversion will under or overflow.
+template <class Dest, class Source>
+inline bool IsValidNumericCast(Source source) {
+  typedef std::numeric_limits<Source> SourceLimits;
+  typedef std::numeric_limits<Dest> DestLimits;
+  static_assert(SourceLimits::is_specialized, "argument must be numeric");
+  static_assert(SourceLimits::is_integer, "argument must be integral");
+  static_assert(DestLimits::is_specialized, "result must be numeric");
+  static_assert(DestLimits::is_integer, "result must be integral");
+
+  return IsValidNumericCastImpl<
+      sizeof(Dest) == sizeof(Source),
+      (sizeof(Dest) > sizeof(Source)),
+      DestLimits::is_signed,
+      SourceLimits::is_signed>::Test(
+          source,
+          DestLimits::min(),
+          DestLimits::max());
+}
+
+// checked_numeric_cast<> is analogous to static_cast<> for numeric types,
+// except that it CHECKs that the specified numeric conversion will not
+// overflow or underflow. Floating point arguments are not currently allowed
+// (this is static_asserted), though this could be supported if necessary.
+template <class Dest, class Source>
+inline Dest checked_numeric_cast(Source source) {
+  GOOGLE_CHECK(IsValidNumericCast<Dest>(source));
+  return static_cast<Dest>(source);
+}
+
+}  // namespace python
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_PYTHON_CPP_SAFE_NUMERICS_H__
diff --git a/lark_channel/ws/pb/google/protobuf/pyext/scoped_pyobject_ptr.h b/lark_channel/ws/pb/google/protobuf/pyext/scoped_pyobject_ptr.h
new file mode 100644
index 0000000..ad3fa94
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/pyext/scoped_pyobject_ptr.h
@@ -0,0 +1,101 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: tibell@google.com (Johan Tibell)
+
+#ifndef GOOGLE_PROTOBUF_PYTHON_CPP_SCOPED_PYOBJECT_PTR_H__
+#define GOOGLE_PROTOBUF_PYTHON_CPP_SCOPED_PYOBJECT_PTR_H__
+
+#include <google/protobuf/stubs/common.h>
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+namespace google {
+namespace protobuf {
+namespace python {
+
+// Owns a python object and decrements the reference count on destruction.
+// This class is not threadsafe.
+template <typename PyObjectStruct>
+class ScopedPythonPtr {
+ public:
+  // Takes the ownership of the specified object to ScopedPythonPtr.
+  // The reference count of the specified py_object is not incremented.
+  explicit ScopedPythonPtr(PyObjectStruct* py_object = nullptr)
+      : ptr_(py_object) {}
+
+  // If a PyObject is owned, decrement its reference count.
+  ~ScopedPythonPtr() { Py_XDECREF(ptr_); }
+
+  // Deletes the current owned object, if any.
+  // Then takes ownership of a new object without incrementing the reference
+  // count.
+  // This function must be called with a reference that you own.
+  //   this->reset(this->get()) is wrong!
+  //   this->reset(this->release()) is OK.
+  PyObjectStruct* reset(PyObjectStruct* p = nullptr) {
+    Py_XDECREF(ptr_);
+    ptr_ = p;
+    return ptr_;
+  }
+
+  // Releases ownership of the object without decrementing the reference count.
+  // The caller now owns the returned reference.
+  PyObjectStruct* release() {
+    PyObject* p = ptr_;
+    ptr_ = nullptr;
+    return p;
+  }
+
+  PyObjectStruct* get() const { return ptr_; }
+
+  PyObject* as_pyobject() const { return reinterpret_cast<PyObject*>(ptr_); }
+
+  // Increments the reference count of the current object.
+  // Should not be called when no object is held.
+  void inc() const { Py_INCREF(ptr_); }
+
+  // True when a ScopedPyObjectPtr and a raw pointer refer to the same object.
+  // Comparison operators are non reflexive.
+  bool operator==(const PyObjectStruct* p) const { return ptr_ == p; }
+  bool operator!=(const PyObjectStruct* p) const { return ptr_ != p; }
+
+ private:
+  PyObjectStruct* ptr_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ScopedPythonPtr);
+};
+
+typedef ScopedPythonPtr<PyObject> ScopedPyObjectPtr;
+
+}  // namespace python
+}  // namespace protobuf
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_PYTHON_CPP_SCOPED_PYOBJECT_PTR_H__
diff --git a/lark_channel/ws/pb/google/protobuf/pyext/unknown_fields.cc b/lark_channel/ws/pb/google/protobuf/pyext/unknown_fields.cc
new file mode 100644
index 0000000..dcd63b2
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/pyext/unknown_fields.cc
@@ -0,0 +1,363 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include <google/protobuf/pyext/unknown_fields.h>
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include <set>
+#include <memory>
+
+#include <google/protobuf/message.h>
+#include <google/protobuf/pyext/message.h>
+#include <google/protobuf/pyext/scoped_pyobject_ptr.h>
+#include <google/protobuf/unknown_field_set.h>
+#include <google/protobuf/wire_format_lite.h>
+
+namespace google {
+namespace protobuf {
+namespace python {
+
+namespace unknown_fields {
+
+static Py_ssize_t Len(PyObject* pself) {
+  PyUnknownFields* self =
+      reinterpret_cast<PyUnknownFields*>(pself);
+  if (self->fields == nullptr) {
+    PyErr_Format(PyExc_ValueError,
+                 "UnknownFields does not exist. "
+                 "The parent message might be cleared.");
+    return -1;
+  }
+  return self->fields->field_count();
+}
+
+void Clear(PyUnknownFields* self) {
+  for (std::set<PyUnknownFields*>::iterator it =
+           self->sub_unknown_fields.begin();
+       it != self->sub_unknown_fields.end(); it++) {
+    Clear(*it);
+  }
+  self->fields = nullptr;
+  self->sub_unknown_fields.clear();
+}
+
+PyObject* NewPyUnknownFieldRef(PyUnknownFields* parent,
+                               Py_ssize_t index);
+
+static PyObject* Item(PyObject* pself, Py_ssize_t index) {
+  PyUnknownFields* self =
+      reinterpret_cast<PyUnknownFields*>(pself);
+  if (self->fields == nullptr) {
+    PyErr_Format(PyExc_ValueError,
+                 "UnknownFields does not exist. "
+                 "The parent message might be cleared.");
+    return nullptr;
+  }
+  Py_ssize_t total_size = self->fields->field_count();
+  if (index < 0) {
+    index = total_size + index;
+  }
+  if (index < 0 || index >= total_size) {
+    PyErr_Format(PyExc_IndexError,
+                 "index (%zd) out of range",
+                 index);
+    return nullptr;
+  }
+
+  return unknown_fields::NewPyUnknownFieldRef(self, index);
+}
+
+PyObject* NewPyUnknownFields(CMessage* c_message) {
+  PyUnknownFields* self = reinterpret_cast<PyUnknownFields*>(
+      PyType_GenericAlloc(&PyUnknownFields_Type, 0));
+  if (self == nullptr) {
+    return nullptr;
+  }
+  // Call "placement new" to initialize PyUnknownFields.
+  new (self) PyUnknownFields;
+
+  Py_INCREF(c_message);
+  self->parent = reinterpret_cast<PyObject*>(c_message);
+  Message* message = c_message->message;
+  const Reflection* reflection = message->GetReflection();
+  self->fields = &reflection->GetUnknownFields(*message);
+
+  return reinterpret_cast<PyObject*>(self);
+}
+
+PyObject* NewPyUnknownFieldRef(PyUnknownFields* parent,
+                               Py_ssize_t index) {
+  PyUnknownFieldRef* self = reinterpret_cast<PyUnknownFieldRef*>(
+      PyType_GenericAlloc(&PyUnknownFieldRef_Type, 0));
+  if (self == nullptr) {
+    return nullptr;
+  }
+
+  Py_INCREF(parent);
+  self->parent = parent;
+  self->index = index;
+
+  return reinterpret_cast<PyObject*>(self);
+}
+
+static void Dealloc(PyObject* pself) {
+  PyUnknownFields* self =
+      reinterpret_cast<PyUnknownFields*>(pself);
+  if (PyObject_TypeCheck(self->parent, &PyUnknownFields_Type)) {
+    reinterpret_cast<PyUnknownFields*>(
+        self->parent)->sub_unknown_fields.erase(self);
+  } else {
+    reinterpret_cast<CMessage*>(self->parent)->unknown_field_set = nullptr;
+  }
+  Py_CLEAR(self->parent);
+  auto* py_type = Py_TYPE(pself);
+  self->~PyUnknownFields();
+  py_type->tp_free(pself);
+}
+
+static PySequenceMethods SqMethods = {
+    Len,     /* sq_length */
+    nullptr, /* sq_concat */
+    nullptr, /* sq_repeat */
+    Item,    /* sq_item */
+    nullptr, /* sq_slice */
+    nullptr, /* sq_ass_item */
+};
+
+}  // namespace unknown_fields
+
+PyTypeObject PyUnknownFields_Type = {
+    PyVarObject_HEAD_INIT(&PyType_Type, 0) FULL_MODULE_NAME
+    ".PyUnknownFields",       // tp_name
+    sizeof(PyUnknownFields),  // tp_basicsize
+    0,                        //  tp_itemsize
+    unknown_fields::Dealloc,  //  tp_dealloc
+#if PY_VERSION_HEX < 0x03080000
+    nullptr,  // tp_print
+#else
+    0,  // tp_vectorcall_offset
+#endif
+    nullptr,                      //  tp_getattr
+    nullptr,                      //  tp_setattr
+    nullptr,                      //  tp_compare
+    nullptr,                      //  tp_repr
+    nullptr,                      //  tp_as_number
+    &unknown_fields::SqMethods,   //  tp_as_sequence
+    nullptr,                      //  tp_as_mapping
+    PyObject_HashNotImplemented,  //  tp_hash
+    nullptr,                      //  tp_call
+    nullptr,                      //  tp_str
+    nullptr,                      //  tp_getattro
+    nullptr,                      //  tp_setattro
+    nullptr,                      //  tp_as_buffer
+    Py_TPFLAGS_DEFAULT,           //  tp_flags
+    "unknown field set",          //  tp_doc
+    nullptr,                      //  tp_traverse
+    nullptr,                      //  tp_clear
+    nullptr,                      //  tp_richcompare
+    0,                            //  tp_weaklistoffset
+    nullptr,                      //  tp_iter
+    nullptr,                      //  tp_iternext
+    nullptr,                      //  tp_methods
+    nullptr,                      //  tp_members
+    nullptr,                      //  tp_getset
+    nullptr,                      //  tp_base
+    nullptr,                      //  tp_dict
+    nullptr,                      //  tp_descr_get
+    nullptr,                      //  tp_descr_set
+    0,                            //  tp_dictoffset
+    nullptr,                      //  tp_init
+};
+
+namespace unknown_field {
+static PyObject* PyUnknownFields_FromUnknownFieldSet(
+    PyUnknownFields* parent, const UnknownFieldSet& fields) {
+  PyUnknownFields* self = reinterpret_cast<PyUnknownFields*>(
+      PyType_GenericAlloc(&PyUnknownFields_Type, 0));
+  if (self == nullptr) {
+    return nullptr;
+  }
+  // Call "placement new" to initialize PyUnknownFields.
+  new (self) PyUnknownFields;
+
+  Py_INCREF(parent);
+  self->parent = reinterpret_cast<PyObject*>(parent);
+  self->fields = &fields;
+  parent->sub_unknown_fields.emplace(self);
+
+  return reinterpret_cast<PyObject*>(self);
+}
+
+const UnknownField* GetUnknownField(PyUnknownFieldRef* self) {
+  const UnknownFieldSet* fields = self->parent->fields;
+  if (fields == nullptr) {
+    PyErr_Format(PyExc_ValueError,
+                 "UnknownField does not exist. "
+                 "The parent message might be cleared.");
+    return nullptr;
+  }
+  Py_ssize_t total_size = fields->field_count();
+  if (self->index >= total_size) {
+    PyErr_Format(PyExc_ValueError,
+                 "UnknownField does not exist. "
+                 "The parent message might be cleared.");
+    return nullptr;
+  }
+  return &fields->field(self->index);
+}
+
+static PyObject* GetFieldNumber(PyUnknownFieldRef* self, void *closure) {
+  const UnknownField* unknown_field = GetUnknownField(self);
+  if (unknown_field == nullptr) {
+    return nullptr;
+  }
+  return PyLong_FromLong(unknown_field->number());
+}
+
+using internal::WireFormatLite;
+static PyObject* GetWireType(PyUnknownFieldRef* self, void *closure) {
+  const UnknownField* unknown_field = GetUnknownField(self);
+  if (unknown_field == nullptr) {
+    return nullptr;
+  }
+
+  // Assign a default value to suppress may-uninitialized warnings (errors
+  // when built in some places).
+  WireFormatLite::WireType wire_type = WireFormatLite::WIRETYPE_VARINT;
+  switch (unknown_field->type()) {
+    case UnknownField::TYPE_VARINT:
+      wire_type = WireFormatLite::WIRETYPE_VARINT;
+      break;
+    case UnknownField::TYPE_FIXED32:
+      wire_type = WireFormatLite::WIRETYPE_FIXED32;
+      break;
+    case UnknownField::TYPE_FIXED64:
+      wire_type = WireFormatLite::WIRETYPE_FIXED64;
+      break;
+    case UnknownField::TYPE_LENGTH_DELIMITED:
+      wire_type = WireFormatLite::WIRETYPE_LENGTH_DELIMITED;
+      break;
+    case UnknownField::TYPE_GROUP:
+      wire_type = WireFormatLite::WIRETYPE_START_GROUP;
+      break;
+  }
+  return PyLong_FromLong(wire_type);
+}
+
+static PyObject* GetData(PyUnknownFieldRef* self, void *closure) {
+  const UnknownField* field = GetUnknownField(self);
+  if (field == nullptr) {
+    return nullptr;
+  }
+  PyObject* data = nullptr;
+  switch (field->type()) {
+    case UnknownField::TYPE_VARINT:
+      data = PyLong_FromUnsignedLongLong(field->varint());
+      break;
+    case UnknownField::TYPE_FIXED32:
+      data = PyLong_FromUnsignedLong(field->fixed32());
+      break;
+    case UnknownField::TYPE_FIXED64:
+      data = PyLong_FromUnsignedLongLong(field->fixed64());
+      break;
+    case UnknownField::TYPE_LENGTH_DELIMITED:
+      data = PyBytes_FromStringAndSize(field->length_delimited().data(),
+                                       field->GetLengthDelimitedSize());
+      break;
+    case UnknownField::TYPE_GROUP:
+      data = PyUnknownFields_FromUnknownFieldSet(
+          self->parent, field->group());
+      break;
+  }
+  return data;
+}
+
+static void Dealloc(PyObject* pself) {
+  PyUnknownFieldRef* self =
+      reinterpret_cast<PyUnknownFieldRef*>(pself);
+  Py_CLEAR(self->parent);
+}
+
+static PyGetSetDef Getters[] = {
+    {"field_number", (getter)GetFieldNumber, nullptr},
+    {"wire_type", (getter)GetWireType, nullptr},
+    {"data", (getter)GetData, nullptr},
+    {nullptr},
+};
+
+}  // namespace unknown_field
+
+PyTypeObject PyUnknownFieldRef_Type = {
+    PyVarObject_HEAD_INIT(&PyType_Type, 0) FULL_MODULE_NAME
+    ".PyUnknownFieldRef",       // tp_name
+    sizeof(PyUnknownFieldRef),  //  tp_basicsize
+    0,                          //  tp_itemsize
+    unknown_field::Dealloc,     //  tp_dealloc
+#if PY_VERSION_HEX < 0x03080000
+    nullptr,  // tp_print
+#else
+    0,  // tp_vectorcall_offset
+#endif
+    nullptr,                      //  tp_getattr
+    nullptr,                      //  tp_setattr
+    nullptr,                      //  tp_compare
+    nullptr,                      //  tp_repr
+    nullptr,                      //  tp_as_number
+    nullptr,                      //  tp_as_sequence
+    nullptr,                      //  tp_as_mapping
+    PyObject_HashNotImplemented,  //  tp_hash
+    nullptr,                      //  tp_call
+    nullptr,                      //  tp_str
+    nullptr,                      //  tp_getattro
+    nullptr,                      //  tp_setattro
+    nullptr,                      //  tp_as_buffer
+    Py_TPFLAGS_DEFAULT,           //  tp_flags
+    "unknown field",              //  tp_doc
+    nullptr,                      //  tp_traverse
+    nullptr,                      //  tp_clear
+    nullptr,                      //  tp_richcompare
+    0,                            //  tp_weaklistoffset
+    nullptr,                      //  tp_iter
+    nullptr,                      //  tp_iternext
+    nullptr,                      //  tp_methods
+    nullptr,                      //  tp_members
+    unknown_field::Getters,       //  tp_getset
+    nullptr,                      //  tp_base
+    nullptr,                      //  tp_dict
+    nullptr,                      //  tp_descr_get
+    nullptr,                      //  tp_descr_set
+    0,                            //  tp_dictoffset
+    nullptr,                      //  tp_init
+};
+
+}  // namespace python
+}  // namespace protobuf
+}  // namespace google
diff --git a/lark_channel/ws/pb/google/protobuf/pyext/unknown_fields.h b/lark_channel/ws/pb/google/protobuf/pyext/unknown_fields.h
new file mode 100644
index 0000000..e7b0b35
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/pyext/unknown_fields.h
@@ -0,0 +1,91 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_PYTHON_CPP_UNKNOWN_FIELDS_H__
+#define GOOGLE_PROTOBUF_PYTHON_CPP_UNKNOWN_FIELDS_H__
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+#include <memory>
+#include <set>
+
+#include <google/protobuf/pyext/message.h>
+
+namespace google {
+namespace protobuf {
+
+class UnknownField;
+class UnknownFieldSet;
+
+namespace python {
+struct CMessage;
+
+typedef struct PyUnknownFields {
+  PyObject_HEAD;
+  // Strong pointer to the parent CMessage or PyUnknownFields.
+  // The top PyUnknownFields holds a reference to its parent CMessage
+  // object before release.
+  // Sub PyUnknownFields holds reference to parent PyUnknownFields.
+  PyObject* parent;
+
+  // Pointer to the C++ UnknownFieldSet.
+  // PyUnknownFields does not own this pointer.
+  const UnknownFieldSet* fields;
+
+  // Weak references to child unknown fields.
+  std::set<PyUnknownFields*> sub_unknown_fields;
+} PyUnknownFields;
+
+typedef struct PyUnknownFieldRef {
+  PyObject_HEAD;
+  // Every Python PyUnknownFieldRef holds a reference to its parent
+  // PyUnknownFields in order to keep it alive.
+  PyUnknownFields* parent;
+
+  // The UnknownField index in UnknownFields.
+  Py_ssize_t index;
+} UknownFieldRef;
+
+extern PyTypeObject PyUnknownFields_Type;
+extern PyTypeObject PyUnknownFieldRef_Type;
+
+namespace unknown_fields {
+
+// Builds an PyUnknownFields for a specific message.
+PyObject* NewPyUnknownFields(CMessage *parent);
+void Clear(PyUnknownFields* self);
+
+}  // namespace unknown_fields
+}  // namespace python
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_PYTHON_CPP_UNKNOWN_FIELDS_H__
diff --git a/lark_channel/ws/pb/google/protobuf/python_protobuf.h b/lark_channel/ws/pb/google/protobuf/python_protobuf.h
new file mode 100644
index 0000000..4fcf065
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/python_protobuf.h
@@ -0,0 +1,58 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: qrczak@google.com (Marcin Kowalczyk)
+//
+// This module exposes the C proto inside the given Python proto, in
+// case the Python proto is implemented with a C proto.
+
+#ifndef GOOGLE_PROTOBUF_PYTHON_PYTHON_PROTOBUF_H__
+#define GOOGLE_PROTOBUF_PYTHON_PYTHON_PROTOBUF_H__
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+namespace google {
+namespace protobuf {
+
+class Message;
+
+namespace python {
+
+// Return the pointer to the C proto inside the given Python proto,
+// or NULL when this is not a Python proto implemented with a C proto.
+const Message* GetCProtoInsidePyProto(PyObject* msg);
+Message* MutableCProtoInsidePyProto(PyObject* msg);
+
+}  // namespace python
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_PYTHON_PYTHON_PROTOBUF_H__
diff --git a/lark_channel/ws/pb/google/protobuf/reflection.py b/lark_channel/ws/pb/google/protobuf/reflection.py
new file mode 100644
index 0000000..5863b2b
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/reflection.py
@@ -0,0 +1,94 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+# https://developers.google.com/protocol-buffers/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# This code is meant to work on Python 2.4 and above only.
+
+"""Contains a metaclass and helper functions used to create
+protocol message classes from Descriptor objects at runtime.
+
+Recall that a metaclass is the "type" of a class.
+(A class is to a metaclass what an instance is to a class.)
+
+In this case, we use the GeneratedProtocolMessageType metaclass
+to inject all the useful functionality into the classes
+output by the protocol compiler at compile-time.
+
+The upshot of all this is that the real implementation
+details for ALL pure-Python protocol buffers are *here in
+this file*.
+"""
+
+__author__ = 'robinson@google.com (Will Robinson)'
+
+from lark_channel.ws.pb.google.protobuf import message_factory
+from lark_channel.ws.pb.google.protobuf import symbol_database
+
+# The type of all Message classes.
+# Part of the public interface, but normally only used by message factories.
+GeneratedProtocolMessageType = message_factory._GENERATED_PROTOCOL_MESSAGE_TYPE
+
+MESSAGE_CLASS_CACHE = {}
+
+
+# Deprecated. Please NEVER use reflection.ParseMessage().
+def ParseMessage(descriptor, byte_str):
+    """Generate a new Message instance from this Descriptor and a byte string.
+
+    DEPRECATED: ParseMessage is deprecated because it is using MakeClass().
+    Please use MessageFactory.GetPrototype() instead.
+
+    Args:
+      descriptor: Protobuf Descriptor object
+      byte_str: Serialized protocol buffer byte string
+
+    Returns:
+      Newly created protobuf Message object.
+    """
+    result_class = MakeClass(descriptor)
+    new_msg = result_class()
+    new_msg.ParseFromString(byte_str)
+    return new_msg
+
+
+# Deprecated. Please NEVER use reflection.MakeClass().
+def MakeClass(descriptor):
+    """Construct a class object for a protobuf described by descriptor.
+
+    DEPRECATED: use MessageFactory.GetPrototype() instead.
+
+    Args:
+      descriptor: A descriptor.Descriptor object describing the protobuf.
+    Returns:
+      The Message class object described by the descriptor.
+    """
+    # Original implementation leads to duplicate message classes, which won't play
+    # well with extensions. Message factory info is also missing.
+    # Redirect to message_factory.
+    return symbol_database.Default().GetPrototype(descriptor)
diff --git a/lark_channel/ws/pb/google/protobuf/service.py b/lark_channel/ws/pb/google/protobuf/service.py
new file mode 100644
index 0000000..974f0d0
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/service.py
@@ -0,0 +1,225 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+# https://developers.google.com/protocol-buffers/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""DEPRECATED:  Declares the RPC service interfaces.
+
+This module declares the abstract interfaces underlying proto2 RPC
+services.  These are intended to be independent of any particular RPC
+implementation, so that proto2 services can be used on top of a variety
+of implementations.  Starting with version 2.3.0, RPC implementations should
+not try to build on these, but should instead provide code generator plugins
+which generate code specific to the particular RPC implementation.  This way
+the generated code can be more appropriate for the implementation in use
+and can avoid unnecessary layers of indirection.
+"""
+
+__author__ = 'petar@google.com (Petar Petrov)'
+
+
+class RpcException(Exception):
+    """Exception raised on failed blocking RPC method call."""
+    pass
+
+
+class Service(object):
+    """Abstract base interface for protocol-buffer-based RPC services.
+
+    Services themselves are abstract classes (implemented either by servers or as
+    stubs), but they subclass this base interface. The methods of this
+    interface can be used to call the methods of the service without knowing
+    its exact type at compile time (analogous to the Message interface).
+    """
+
+    def GetDescriptor():
+        """Retrieves this service's descriptor."""
+        raise NotImplementedError
+
+    def CallMethod(self, method_descriptor, rpc_controller,
+                   request, done):
+        """Calls a method of the service specified by method_descriptor.
+
+        If "done" is None then the call is blocking and the response
+        message will be returned directly.  Otherwise the call is asynchronous
+        and "done" will later be called with the response value.
+
+        In the blocking case, RpcException will be raised on error.
+
+        Preconditions:
+
+        * method_descriptor.service == GetDescriptor
+        * request is of the exact same classes as returned by
+          GetRequestClass(method).
+        * After the call has started, the request must not be modified.
+        * "rpc_controller" is of the correct type for the RPC implementation being
+          used by this Service.  For stubs, the "correct type" depends on the
+          RpcChannel which the stub is using.
+
+        Postconditions:
+
+        * "done" will be called when the method is complete.  This may be
+          before CallMethod() returns or it may be at some point in the future.
+        * If the RPC failed, the response value passed to "done" will be None.
+          Further details about the failure can be found by querying the
+          RpcController.
+        """
+        raise NotImplementedError
+
+    def GetRequestClass(self, method_descriptor):
+        """Returns the class of the request message for the specified method.
+
+        CallMethod() requires that the request is of a particular subclass of
+        Message. GetRequestClass() gets the default instance of this required
+        type.
+
+        Example:
+          method = service.GetDescriptor().FindMethodByName("Foo")
+          request = stub.GetRequestClass(method)()
+          request.ParseFromString(input)
+          service.CallMethod(method, request, callback)
+        """
+        raise NotImplementedError
+
+    def GetResponseClass(self, method_descriptor):
+        """Returns the class of the response message for the specified method.
+
+        This method isn't really needed, as the RpcChannel's CallMethod constructs
+        the response protocol message. It's provided anyway in case it is useful
+        for the caller to know the response type in advance.
+        """
+        raise NotImplementedError
+
+
+class RpcController(object):
+    """An RpcController mediates a single method call.
+
+    The primary purpose of the controller is to provide a way to manipulate
+    settings specific to the RPC implementation and to find out about RPC-level
+    errors. The methods provided by the RpcController interface are intended
+    to be a "least common denominator" set of features which we expect all
+    implementations to support.  Specific implementations may provide more
+    advanced features (e.g. deadline propagation).
+    """
+
+    # Client-side methods below
+
+    def Reset(self):
+        """Resets the RpcController to its initial state.
+
+        After the RpcController has been reset, it may be reused in
+        a new call. Must not be called while an RPC is in progress.
+        """
+        raise NotImplementedError
+
+    def Failed(self):
+        """Returns true if the call failed.
+
+        After a call has finished, returns true if the call failed.  The possible
+        reasons for failure depend on the RPC implementation.  Failed() must not
+        be called before a call has finished.  If Failed() returns true, the
+        contents of the response message are undefined.
+        """
+        raise NotImplementedError
+
+    def ErrorText(self):
+        """If Failed is true, returns a human-readable description of the error."""
+        raise NotImplementedError
+
+    def StartCancel(self):
+        """Initiate cancellation.
+
+        Advises the RPC system that the caller desires that the RPC call be
+        canceled.  The RPC system may cancel it immediately, may wait awhile and
+        then cancel it, or may not even cancel the call at all.  If the call is
+        canceled, the "done" callback will still be called and the RpcController
+        will indicate that the call failed at that time.
+        """
+        raise NotImplementedError
+
+    # Server-side methods below
+
+    def SetFailed(self, reason):
+        """Sets a failure reason.
+
+        Causes Failed() to return true on the client side.  "reason" will be
+        incorporated into the message returned by ErrorText().  If you find
+        you need to return machine-readable information about failures, you
+        should incorporate it into your response protocol buffer and should
+        NOT call SetFailed().
+        """
+        raise NotImplementedError
+
+    def IsCanceled(self):
+        """Checks if the client cancelled the RPC.
+
+        If true, indicates that the client canceled the RPC, so the server may
+        as well give up on replying to it.  The server should still call the
+        final "done" callback.
+        """
+        raise NotImplementedError
+
+    def NotifyOnCancel(self, callback):
+        """Sets a callback to invoke on cancel.
+
+        Asks that the given callback be called when the RPC is canceled.  The
+        callback will always be called exactly once.  If the RPC completes without
+        being canceled, the callback will be called after completion.  If the RPC
+        has already been canceled when NotifyOnCancel() is called, the callback
+        will be called immediately.
+
+        NotifyOnCancel() must be called no more than once per request.
+        """
+        raise NotImplementedError
+
+
+class RpcChannel(object):
+    """Abstract interface for an RPC channel.
+
+    An RpcChannel represents a communication line to a service which can be used
+    to call that service's methods.  The service may be running on another
+    machine. Normally, you should not use an RpcChannel directly, but instead
+    construct a stub {@link Service} wrapping it.  Example:
+
+    Example:
+      RpcChannel channel = rpcImpl.Channel("remotehost.example.com:1234")
+      RpcController controller = rpcImpl.Controller()
+      MyService service = MyService_Stub(channel)
+      service.MyMethod(controller, request, callback)
+    """
+
+    def CallMethod(self, method_descriptor, rpc_controller,
+                   request, response_class, done):
+        """Calls the method identified by the descriptor.
+
+        Call the given method of the remote service.  The signature of this
+        procedure looks the same as Service.CallMethod(), but the requirements
+        are less strict in one important way:  the request object doesn't have to
+        be of any specific class as long as its descriptor is method.input_type.
+        """
+        raise NotImplementedError
diff --git a/lark_channel/ws/pb/google/protobuf/service_reflection.py b/lark_channel/ws/pb/google/protobuf/service_reflection.py
new file mode 100644
index 0000000..4cf9595
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/service_reflection.py
@@ -0,0 +1,292 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+# https://developers.google.com/protocol-buffers/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""Contains metaclasses used to create protocol service and service stub
+classes from ServiceDescriptor objects at runtime.
+
+The GeneratedServiceType and GeneratedServiceStubType metaclasses are used to
+inject all useful functionality into the classes output by the protocol
+compiler at compile-time.
+"""
+
+__author__ = 'petar@google.com (Petar Petrov)'
+
+
+class GeneratedServiceType(type):
+    """Metaclass for service classes created at runtime from ServiceDescriptors.
+
+    Implementations for all methods described in the Service class are added here
+    by this class. We also create properties to allow getting/setting all fields
+    in the protocol message.
+
+    The protocol compiler currently uses this metaclass to create protocol service
+    classes at runtime. Clients can also manually create their own classes at
+    runtime, as in this example::
+
+      mydescriptor = ServiceDescriptor(.....)
+      class MyProtoService(service.Service):
+        __metaclass__ = GeneratedServiceType
+        DESCRIPTOR = mydescriptor
+      myservice_instance = MyProtoService()
+      # ...
+    """
+
+    _DESCRIPTOR_KEY = 'DESCRIPTOR'
+
+    def __init__(cls, name, bases, dictionary):
+        """Creates a message service class.
+
+        Args:
+          name: Name of the class (ignored, but required by the metaclass
+            protocol).
+          bases: Base classes of the class being constructed.
+          dictionary: The class dictionary of the class being constructed.
+            dictionary[_DESCRIPTOR_KEY] must contain a ServiceDescriptor object
+            describing this protocol service type.
+        """
+        # Don't do anything if this class doesn't have a descriptor. This happens
+        # when a service class is subclassed.
+        if GeneratedServiceType._DESCRIPTOR_KEY not in dictionary:
+            return
+
+        descriptor = dictionary[GeneratedServiceType._DESCRIPTOR_KEY]
+        service_builder = _ServiceBuilder(descriptor)
+        service_builder.BuildService(cls)
+        cls.DESCRIPTOR = descriptor
+
+
+class GeneratedServiceStubType(GeneratedServiceType):
+    """Metaclass for service stubs created at runtime from ServiceDescriptors.
+
+    This class has similar responsibilities as GeneratedServiceType, except that
+    it creates the service stub classes.
+    """
+
+    _DESCRIPTOR_KEY = 'DESCRIPTOR'
+
+    def __init__(cls, name, bases, dictionary):
+        """Creates a message service stub class.
+
+        Args:
+          name: Name of the class (ignored, here).
+          bases: Base classes of the class being constructed.
+          dictionary: The class dictionary of the class being constructed.
+            dictionary[_DESCRIPTOR_KEY] must contain a ServiceDescriptor object
+            describing this protocol service type.
+        """
+        super(GeneratedServiceStubType, cls).__init__(name, bases, dictionary)
+        # Don't do anything if this class doesn't have a descriptor. This happens
+        # when a service stub is subclassed.
+        if GeneratedServiceStubType._DESCRIPTOR_KEY not in dictionary:
+            return
+
+        descriptor = dictionary[GeneratedServiceStubType._DESCRIPTOR_KEY]
+        service_stub_builder = _ServiceStubBuilder(descriptor)
+        service_stub_builder.BuildServiceStub(cls)
+
+
+class _ServiceBuilder(object):
+    """This class constructs a protocol service class using a service descriptor.
+
+    Given a service descriptor, this class constructs a class that represents
+    the specified service descriptor. One service builder instance constructs
+    exactly one service class. That means all instances of that class share the
+    same builder.
+    """
+
+    def __init__(self, service_descriptor):
+        """Initializes an instance of the service class builder.
+
+        Args:
+          service_descriptor: ServiceDescriptor to use when constructing the
+            service class.
+        """
+        self.descriptor = service_descriptor
+
+    def BuildService(builder, cls):
+        """Constructs the service class.
+
+        Args:
+          cls: The class that will be constructed.
+        """
+
+        # CallMethod needs to operate with an instance of the Service class. This
+        # internal wrapper function exists only to be able to pass the service
+        # instance to the method that does the real CallMethod work.
+        # Making sure to use exact argument names from the abstract interface in
+        # service.py to match the type signature
+        def _WrapCallMethod(self, method_descriptor, rpc_controller, request, done):
+            return builder._CallMethod(self, method_descriptor, rpc_controller,
+                                       request, done)
+
+        def _WrapGetRequestClass(self, method_descriptor):
+            return builder._GetRequestClass(method_descriptor)
+
+        def _WrapGetResponseClass(self, method_descriptor):
+            return builder._GetResponseClass(method_descriptor)
+
+        builder.cls = cls
+        cls.CallMethod = _WrapCallMethod
+        cls.GetDescriptor = staticmethod(lambda: builder.descriptor)
+        cls.GetDescriptor.__doc__ = 'Returns the service descriptor.'
+        cls.GetRequestClass = _WrapGetRequestClass
+        cls.GetResponseClass = _WrapGetResponseClass
+        for method in builder.descriptor.methods:
+            setattr(cls, method.name, builder._GenerateNonImplementedMethod(method))
+
+    def _CallMethod(self, srvc, method_descriptor,
+                    rpc_controller, request, callback):
+        """Calls the method described by a given method descriptor.
+
+        Args:
+          srvc: Instance of the service for which this method is called.
+          method_descriptor: Descriptor that represent the method to call.
+          rpc_controller: RPC controller to use for this method's execution.
+          request: Request protocol message.
+          callback: A callback to invoke after the method has completed.
+        """
+        if method_descriptor.containing_service != self.descriptor:
+            raise RuntimeError(
+                'CallMethod() given method descriptor for wrong service type.')
+        method = getattr(srvc, method_descriptor.name)
+        return method(rpc_controller, request, callback)
+
+    def _GetRequestClass(self, method_descriptor):
+        """Returns the class of the request protocol message.
+
+        Args:
+          method_descriptor: Descriptor of the method for which to return the
+            request protocol message class.
+
+        Returns:
+          A class that represents the input protocol message of the specified
+          method.
+        """
+        if method_descriptor.containing_service != self.descriptor:
+            raise RuntimeError(
+                'GetRequestClass() given method descriptor for wrong service type.')
+        return method_descriptor.input_type._concrete_class
+
+    def _GetResponseClass(self, method_descriptor):
+        """Returns the class of the response protocol message.
+
+        Args:
+          method_descriptor: Descriptor of the method for which to return the
+            response protocol message class.
+
+        Returns:
+          A class that represents the output protocol message of the specified
+          method.
+        """
+        if method_descriptor.containing_service != self.descriptor:
+            raise RuntimeError(
+                'GetResponseClass() given method descriptor for wrong service type.')
+        return method_descriptor.output_type._concrete_class
+
+    def _GenerateNonImplementedMethod(self, method):
+        """Generates and returns a method that can be set for a service methods.
+
+        Args:
+          method: Descriptor of the service method for which a method is to be
+            generated.
+
+        Returns:
+          A method that can be added to the service class.
+        """
+        return lambda inst, rpc_controller, request, callback: (
+            self._NonImplementedMethod(method.name, rpc_controller, callback))
+
+    def _NonImplementedMethod(self, method_name, rpc_controller, callback):
+        """The body of all methods in the generated service class.
+
+        Args:
+          method_name: Name of the method being executed.
+          rpc_controller: RPC controller used to execute this method.
+          callback: A callback which will be invoked when the method finishes.
+        """
+        rpc_controller.SetFailed('Method %s not implemented.' % method_name)
+        callback(None)
+
+
+class _ServiceStubBuilder(object):
+    """Constructs a protocol service stub class using a service descriptor.
+
+    Given a service descriptor, this class constructs a suitable stub class.
+    A stub is just a type-safe wrapper around an RpcChannel which emulates a
+    local implementation of the service.
+
+    One service stub builder instance constructs exactly one class. It means all
+    instances of that class share the same service stub builder.
+    """
+
+    def __init__(self, service_descriptor):
+        """Initializes an instance of the service stub class builder.
+
+        Args:
+          service_descriptor: ServiceDescriptor to use when constructing the
+            stub class.
+        """
+        self.descriptor = service_descriptor
+
+    def BuildServiceStub(self, cls):
+        """Constructs the stub class.
+
+        Args:
+          cls: The class that will be constructed.
+        """
+
+        def _ServiceStubInit(stub, rpc_channel):
+            stub.rpc_channel = rpc_channel
+
+        self.cls = cls
+        cls.__init__ = _ServiceStubInit
+        for method in self.descriptor.methods:
+            setattr(cls, method.name, self._GenerateStubMethod(method))
+
+    def _GenerateStubMethod(self, method):
+        return (lambda inst, rpc_controller, request, callback=None:
+                self._StubMethod(inst, method, rpc_controller, request, callback))
+
+    def _StubMethod(self, stub, method_descriptor,
+                    rpc_controller, request, callback):
+        """The body of all service methods in the generated stub class.
+
+        Args:
+          stub: Stub instance.
+          method_descriptor: Descriptor of the invoked method.
+          rpc_controller: Rpc controller to execute the method.
+          request: Request protocol message.
+          callback: A callback to execute when the method finishes.
+        Returns:
+          Response message (in case of blocking call).
+        """
+        return stub.rpc_channel.CallMethod(
+            method_descriptor, rpc_controller, request,
+            method_descriptor.output_type._concrete_class, callback)
diff --git a/lark_channel/ws/pb/google/protobuf/source_context_pb2.py b/lark_channel/ws/pb/google/protobuf/source_context_pb2.py
new file mode 100644
index 0000000..5cdfb90
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/source_context_pb2.py
@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+# source: google/protobuf/source_context.proto
+"""Generated protocol buffer code."""
+from lark_channel.ws.pb.google.protobuf.internal import builder as _builder
+from lark_channel.ws.pb.google.protobuf import descriptor as _descriptor
+from lark_channel.ws.pb.google.protobuf import descriptor_pool as _descriptor_pool
+from lark_channel.ws.pb.google.protobuf import symbol_database as _symbol_database
+
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(
+    b'\n$google/protobuf/source_context.proto\x12\x0fgoogle.protobuf\"\"\n\rSourceContext\x12\x11\n\tfile_name\x18\x01 \x01(\tB\x8a\x01\n\x13\x63om.google.protobufB\x12SourceContextProtoP\x01Z6google.golang.org/protobuf/types/known/sourcecontextpb\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesb\x06proto3')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.source_context_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+    DESCRIPTOR._options = None
+    DESCRIPTOR._serialized_options = b'\n\023com.google.protobufB\022SourceContextProtoP\001Z6google.golang.org/protobuf/types/known/sourcecontextpb\242\002\003GPB\252\002\036Google.Protobuf.WellKnownTypes'
+    _SOURCECONTEXT._serialized_start = 57
+    _SOURCECONTEXT._serialized_end = 91
+# @@protoc_insertion_point(module_scope)
diff --git a/lark_channel/ws/pb/google/protobuf/struct_pb2.py b/lark_channel/ws/pb/google/protobuf/struct_pb2.py
new file mode 100644
index 0000000..5961014
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/struct_pb2.py
@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+# source: google/protobuf/struct.proto
+"""Generated protocol buffer code."""
+from lark_channel.ws.pb.google.protobuf.internal import builder as _builder
+from lark_channel.ws.pb.google.protobuf import descriptor as _descriptor
+from lark_channel.ws.pb.google.protobuf import descriptor_pool as _descriptor_pool
+from lark_channel.ws.pb.google.protobuf import symbol_database as _symbol_database
+
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(
+    b'\n\x1cgoogle/protobuf/struct.proto\x12\x0fgoogle.protobuf\"\x84\x01\n\x06Struct\x12\x33\n\x06\x66ields\x18\x01 \x03(\x0b\x32#.google.protobuf.Struct.FieldsEntry\x1a\x45\n\x0b\x46ieldsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12%\n\x05value\x18\x02 \x01(\x0b\x32\x16.google.protobuf.Value:\x02\x38\x01\"\xea\x01\n\x05Value\x12\x30\n\nnull_value\x18\x01 \x01(\x0e\x32\x1a.google.protobuf.NullValueH\x00\x12\x16\n\x0cnumber_value\x18\x02 \x01(\x01H\x00\x12\x16\n\x0cstring_value\x18\x03 \x01(\tH\x00\x12\x14\n\nbool_value\x18\x04 \x01(\x08H\x00\x12/\n\x0cstruct_value\x18\x05 \x01(\x0b\x32\x17.google.protobuf.StructH\x00\x12\x30\n\nlist_value\x18\x06 \x01(\x0b\x32\x1a.google.protobuf.ListValueH\x00\x42\x06\n\x04kind\"3\n\tListValue\x12&\n\x06values\x18\x01 \x03(\x0b\x32\x16.google.protobuf.Value*\x1b\n\tNullValue\x12\x0e\n\nNULL_VALUE\x10\x00\x42\x7f\n\x13\x63om.google.protobufB\x0bStructProtoP\x01Z/google.golang.org/protobuf/types/known/structpb\xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesb\x06proto3')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.struct_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+    DESCRIPTOR._options = None
+    DESCRIPTOR._serialized_options = b'\n\023com.google.protobufB\013StructProtoP\001Z/google.golang.org/protobuf/types/known/structpb\370\001\001\242\002\003GPB\252\002\036Google.Protobuf.WellKnownTypes'
+    _STRUCT_FIELDSENTRY._options = None
+    _STRUCT_FIELDSENTRY._serialized_options = b'8\001'
+    _NULLVALUE._serialized_start = 474
+    _NULLVALUE._serialized_end = 501
+    _STRUCT._serialized_start = 50
+    _STRUCT._serialized_end = 182
+    _STRUCT_FIELDSENTRY._serialized_start = 113
+    _STRUCT_FIELDSENTRY._serialized_end = 182
+    _VALUE._serialized_start = 185
+    _VALUE._serialized_end = 419
+    _LISTVALUE._serialized_start = 421
+    _LISTVALUE._serialized_end = 472
+# @@protoc_insertion_point(module_scope)
diff --git a/lark_channel/ws/pb/google/protobuf/symbol_database.py b/lark_channel/ws/pb/google/protobuf/symbol_database.py
new file mode 100644
index 0000000..985b805
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/symbol_database.py
@@ -0,0 +1,193 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+# https://developers.google.com/protocol-buffers/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""A database of Python protocol buffer generated symbols.
+
+SymbolDatabase is the MessageFactory for messages generated at compile time,
+and makes it easy to create new instances of a registered type, given only the
+type's protocol buffer symbol name.
+
+Example usage::
+
+  db = symbol_database.SymbolDatabase()
+
+  # Register symbols of interest, from one or multiple files.
+  db.RegisterFileDescriptor(my_proto_pb2.DESCRIPTOR)
+  db.RegisterMessage(my_proto_pb2.MyMessage)
+  db.RegisterEnumDescriptor(my_proto_pb2.MyEnum.DESCRIPTOR)
+
+  # The database can be used as a MessageFactory, to generate types based on
+  # their name:
+  types = db.GetMessages(['my_proto.proto'])
+  my_message_instance = types['MyMessage']()
+
+  # The database's underlying descriptor pool can be queried, so it's not
+  # necessary to know a type's filename to be able to generate it:
+  filename = db.pool.FindFileContainingSymbol('MyMessage')
+  my_message_instance = db.GetMessages([filename])['MyMessage']()
+
+  # This functionality is also provided directly via a convenience method:
+  my_message_instance = db.GetSymbol('MyMessage')()
+"""
+
+from lark_channel.ws.pb.google.protobuf.internal import api_implementation
+from lark_channel.ws.pb.google.protobuf import descriptor_pool
+from lark_channel.ws.pb.google.protobuf import message_factory
+
+
+class SymbolDatabase(message_factory.MessageFactory):
+    """A database of Python generated symbols."""
+
+    def RegisterMessage(self, message):
+        """Registers the given message type in the local database.
+
+        Calls to GetSymbol() and GetMessages() will return messages registered here.
+
+        Args:
+          message: A :class:`google.protobuf.message.Message` subclass (or
+            instance); its descriptor will be registered.
+
+        Returns:
+          The provided message.
+        """
+
+        desc = message.DESCRIPTOR
+        self._classes[desc] = message
+        self.RegisterMessageDescriptor(desc)
+        return message
+
+    def RegisterMessageDescriptor(self, message_descriptor):
+        """Registers the given message descriptor in the local database.
+
+        Args:
+          message_descriptor (Descriptor): the message descriptor to add.
+        """
+        if api_implementation.Type() == 'python':
+            # pylint: disable=protected-access
+            self.pool._AddDescriptor(message_descriptor)
+
+    def RegisterEnumDescriptor(self, enum_descriptor):
+        """Registers the given enum descriptor in the local database.
+
+        Args:
+          enum_descriptor (EnumDescriptor): The enum descriptor to register.
+
+        Returns:
+          EnumDescriptor: The provided descriptor.
+        """
+        if api_implementation.Type() == 'python':
+            # pylint: disable=protected-access
+            self.pool._AddEnumDescriptor(enum_descriptor)
+        return enum_descriptor
+
+    def RegisterServiceDescriptor(self, service_descriptor):
+        """Registers the given service descriptor in the local database.
+
+        Args:
+          service_descriptor (ServiceDescriptor): the service descriptor to
+            register.
+        """
+        if api_implementation.Type() == 'python':
+            # pylint: disable=protected-access
+            self.pool._AddServiceDescriptor(service_descriptor)
+
+    def RegisterFileDescriptor(self, file_descriptor):
+        """Registers the given file descriptor in the local database.
+
+        Args:
+          file_descriptor (FileDescriptor): The file descriptor to register.
+        """
+        if api_implementation.Type() == 'python':
+            # pylint: disable=protected-access
+            self.pool._InternalAddFileDescriptor(file_descriptor)
+
+    def GetSymbol(self, symbol):
+        """Tries to find a symbol in the local database.
+
+        Currently, this method only returns message.Message instances, however, if
+        may be extended in future to support other symbol types.
+
+        Args:
+          symbol (str): a protocol buffer symbol.
+
+        Returns:
+          A Python class corresponding to the symbol.
+
+        Raises:
+          KeyError: if the symbol could not be found.
+        """
+
+        return self._classes[self.pool.FindMessageTypeByName(symbol)]
+
+    def GetMessages(self, files):
+        # TODO(amauryfa): Fix the differences with MessageFactory.
+        """Gets all registered messages from a specified file.
+
+        Only messages already created and registered will be returned; (this is the
+        case for imported _pb2 modules)
+        But unlike MessageFactory, this version also returns already defined nested
+        messages, but does not register any message extensions.
+
+        Args:
+          files (list[str]): The file names to extract messages from.
+
+        Returns:
+          A dictionary mapping proto names to the message classes.
+
+        Raises:
+          KeyError: if a file could not be found.
+        """
+
+        def _GetAllMessages(desc):
+            """Walk a message Descriptor and recursively yields all message names."""
+            yield desc
+            for msg_desc in desc.nested_types:
+                for nested_desc in _GetAllMessages(msg_desc):
+                    yield nested_desc
+
+        result = {}
+        for file_name in files:
+            file_desc = self.pool.FindFileByName(file_name)
+            for msg_desc in file_desc.message_types_by_name.values():
+                for desc in _GetAllMessages(msg_desc):
+                    try:
+                        result[desc.full_name] = self._classes[desc]
+                    except KeyError:
+                        # This descriptor has no registered class, skip it.
+                        pass
+        return result
+
+
+_DEFAULT = SymbolDatabase(pool=descriptor_pool.Default())
+
+
+def Default():
+    """Returns the default SymbolDatabase."""
+    return _DEFAULT
diff --git a/lark_channel/ws/pb/google/protobuf/text_encoding.py b/lark_channel/ws/pb/google/protobuf/text_encoding.py
new file mode 100644
index 0000000..29e22db
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/text_encoding.py
@@ -0,0 +1,110 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+# https://developers.google.com/protocol-buffers/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""Encoding related utilities."""
+import re
+
+_cescape_chr_to_symbol_map = {}
+_cescape_chr_to_symbol_map[9] = r'\t'  # optional escape
+_cescape_chr_to_symbol_map[10] = r'\n'  # optional escape
+_cescape_chr_to_symbol_map[13] = r'\r'  # optional escape
+_cescape_chr_to_symbol_map[34] = r'\"'  # necessary escape
+_cescape_chr_to_symbol_map[39] = r"\'"  # optional escape
+_cescape_chr_to_symbol_map[92] = r'\\'  # necessary escape
+
+# Lookup table for unicode
+_cescape_unicode_to_str = [chr(i) for i in range(0, 256)]
+for byte, string in _cescape_chr_to_symbol_map.items():
+    _cescape_unicode_to_str[byte] = string
+
+# Lookup table for non-utf8, with necessary escapes at (o >= 127 or o < 32)
+_cescape_byte_to_str = ([r'\%03o' % i for i in range(0, 32)] +
+                        [chr(i) for i in range(32, 127)] +
+                        [r'\%03o' % i for i in range(127, 256)])
+for byte, string in _cescape_chr_to_symbol_map.items():
+    _cescape_byte_to_str[byte] = string
+del byte, string
+
+
+def CEscape(text, as_utf8):
+    # type: (...) -> str
+    """Escape a bytes string for use in an text protocol buffer.
+
+    Args:
+      text: A byte string to be escaped.
+      as_utf8: Specifies if result may contain non-ASCII characters.
+          In Python 3 this allows unescaped non-ASCII Unicode characters.
+          In Python 2 the return value will be valid UTF-8 rather than only ASCII.
+    Returns:
+      Escaped string (str).
+    """
+    # Python's text.encode() 'string_escape' or 'unicode_escape' codecs do not
+    # satisfy our needs; they encodes unprintable characters using two-digit hex
+    # escapes whereas our C++ unescaping function allows hex escapes to be any
+    # length.  So, "\0011".encode('string_escape') ends up being "\\x011", which
+    # will be decoded in C++ as a single-character string with char code 0x11.
+    text_is_unicode = isinstance(text, str)
+    if as_utf8 and text_is_unicode:
+        # We're already unicode, no processing beyond control char escapes.
+        return text.translate(_cescape_chr_to_symbol_map)
+    ord_ = ord if text_is_unicode else lambda x: x  # bytes iterate as ints.
+    if as_utf8:
+        return ''.join(_cescape_unicode_to_str[ord_(c)] for c in text)
+    return ''.join(_cescape_byte_to_str[ord_(c)] for c in text)
+
+
+_CUNESCAPE_HEX = re.compile(r'(\\+)x([0-9a-fA-F])(?![0-9a-fA-F])')
+
+
+def CUnescape(text):
+    # type: (str) -> bytes
+    """Unescape a text string with C-style escape sequences to UTF-8 bytes.
+
+    Args:
+      text: The data to parse in a str.
+    Returns:
+      A byte string.
+    """
+
+    def ReplaceHex(m):
+        # Only replace the match if the number of leading back slashes is odd. i.e.
+        # the slash itself is not escaped.
+        if len(m.group(1)) & 1:
+            return m.group(1) + 'x0' + m.group(2)
+        return m.group(0)
+
+    # This is required because the 'string_escape' encoding doesn't
+    # allow single-digit hex escapes (like '\xf').
+    result = _CUNESCAPE_HEX.sub(ReplaceHex, text)
+
+    return (result.encode('utf-8')  # Make it bytes to allow decode.
+            .decode('unicode_escape')
+            # Make it bytes again to return the proper type.
+            .encode('raw_unicode_escape'))
diff --git a/lark_channel/ws/pb/google/protobuf/text_format.py b/lark_channel/ws/pb/google/protobuf/text_format.py
new file mode 100644
index 0000000..c5d2db8
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/text_format.py
@@ -0,0 +1,1794 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+# https://developers.google.com/protocol-buffers/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""Contains routines for printing protocol messages in text format.
+
+Simple usage example::
+
+  # Create a proto object and serialize it to a text proto string.
+  message = my_proto_pb2.MyMessage(foo='bar')
+  text_proto = text_format.MessageToString(message)
+
+  # Parse a text proto string.
+  message = text_format.Parse(text_proto, my_proto_pb2.MyMessage())
+"""
+
+__author__ = 'kenton@google.com (Kenton Varda)'
+
+# TODO(b/129989314) Import thread contention leads to test failures.
+import encodings.raw_unicode_escape  # pylint: disable=unused-import
+import encodings.unicode_escape  # pylint: disable=unused-import
+import io
+import math
+import re
+
+from lark_channel.ws.pb.google.protobuf.internal import decoder
+from lark_channel.ws.pb.google.protobuf.internal import type_checkers
+from lark_channel.ws.pb.google.protobuf import descriptor
+from lark_channel.ws.pb.google.protobuf import text_encoding
+
+# pylint: disable=g-import-not-at-top
+__all__ = ['MessageToString', 'Parse', 'PrintMessage', 'PrintField',
+           'PrintFieldValue', 'Merge', 'MessageToBytes']
+
+_INTEGER_CHECKERS = (type_checkers.Uint32ValueChecker(),
+                     type_checkers.Int32ValueChecker(),
+                     type_checkers.Uint64ValueChecker(),
+                     type_checkers.Int64ValueChecker())
+_FLOAT_INFINITY = re.compile('-?inf(?:inity)?f?$', re.IGNORECASE)
+_FLOAT_NAN = re.compile('nanf?$', re.IGNORECASE)
+_QUOTES = frozenset(("'", '"'))
+_ANY_FULL_TYPE_NAME = 'google.protobuf.Any'
+
+
+class Error(Exception):
+    """Top-level module error for text_format."""
+
+
+class ParseError(Error):
+    """Thrown in case of text parsing or tokenizing error."""
+
+    def __init__(self, message=None, line=None, column=None):
+        if message is not None and line is not None:
+            loc = str(line)
+            if column is not None:
+                loc += ':{0}'.format(column)
+            message = '{0} : {1}'.format(loc, message)
+        if message is not None:
+            super(ParseError, self).__init__(message)
+        else:
+            super(ParseError, self).__init__()
+        self._line = line
+        self._column = column
+
+    def GetLine(self):
+        return self._line
+
+    def GetColumn(self):
+        return self._column
+
+
+class TextWriter(object):
+
+    def __init__(self, as_utf8):
+        self._writer = io.StringIO()
+
+    def write(self, val):
+        return self._writer.write(val)
+
+    def close(self):
+        return self._writer.close()
+
+    def getvalue(self):
+        return self._writer.getvalue()
+
+
+def MessageToString(
+        message,
+        as_utf8=False,
+        as_one_line=False,
+        use_short_repeated_primitives=False,
+        pointy_brackets=False,
+        use_index_order=False,
+        float_format=None,
+        double_format=None,
+        use_field_number=False,
+        descriptor_pool=None,
+        indent=0,
+        message_formatter=None,
+        print_unknown_fields=False,
+        force_colon=False):
+    # type: (...) -> str
+    """Convert protobuf message to text format.
+
+    Double values can be formatted compactly with 15 digits of
+    precision (which is the most that IEEE 754 "double" can guarantee)
+    using double_format='.15g'. To ensure that converting to text and back to a
+    proto will result in an identical value, double_format='.17g' should be used.
+
+    Args:
+      message: The protocol buffers message.
+      as_utf8: Return unescaped Unicode for non-ASCII characters.
+          In Python 3 actual Unicode characters may appear as is in strings.
+          In Python 2 the return value will be valid UTF-8 rather than only ASCII.
+      as_one_line: Don't introduce newlines between fields.
+      use_short_repeated_primitives: Use short repeated format for primitives.
+      pointy_brackets: If True, use angle brackets instead of curly braces for
+        nesting.
+      use_index_order: If True, fields of a proto message will be printed using
+        the order defined in source code instead of the field number, extensions
+        will be printed at the end of the message and their relative order is
+        determined by the extension number. By default, use the field number
+        order.
+      float_format (str): If set, use this to specify float field formatting
+        (per the "Format Specification Mini-Language"); otherwise, shortest float
+        that has same value in wire will be printed. Also affect double field
+        if double_format is not set but float_format is set.
+      double_format (str): If set, use this to specify double field formatting
+        (per the "Format Specification Mini-Language"); if it is not set but
+        float_format is set, use float_format. Otherwise, use ``str()``
+      use_field_number: If True, print field numbers instead of names.
+      descriptor_pool (DescriptorPool): Descriptor pool used to resolve Any types.
+      indent (int): The initial indent level, in terms of spaces, for pretty
+        print.
+      message_formatter (function(message, indent, as_one_line) -> unicode|None):
+        Custom formatter for selected sub-messages (usually based on message
+        type). Use to pretty print parts of the protobuf for easier diffing.
+      print_unknown_fields: If True, unknown fields will be printed.
+      force_colon: If set, a colon will be added after the field name even if the
+        field is a proto message.
+
+    Returns:
+      str: A string of the text formatted protocol buffer message.
+    """
+    out = TextWriter(as_utf8)
+    printer = _Printer(
+        out,
+        indent,
+        as_utf8,
+        as_one_line,
+        use_short_repeated_primitives,
+        pointy_brackets,
+        use_index_order,
+        float_format,
+        double_format,
+        use_field_number,
+        descriptor_pool,
+        message_formatter,
+        print_unknown_fields=print_unknown_fields,
+        force_colon=force_colon)
+    printer.PrintMessage(message)
+    result = out.getvalue()
+    out.close()
+    if as_one_line:
+        return result.rstrip()
+    return result
+
+
+def MessageToBytes(message, **kwargs):
+    # type: (...) -> bytes
+    """Convert protobuf message to encoded text format.  See MessageToString."""
+    text = MessageToString(message, **kwargs)
+    if isinstance(text, bytes):
+        return text
+    codec = 'utf-8' if kwargs.get('as_utf8') else 'ascii'
+    return text.encode(codec)
+
+
+def _IsMapEntry(field):
+    return (field.type == descriptor.FieldDescriptor.TYPE_MESSAGE and
+            field.message_type.has_options and
+            field.message_type.GetOptions().map_entry)
+
+
+def PrintMessage(message,
+                 out,
+                 indent=0,
+                 as_utf8=False,
+                 as_one_line=False,
+                 use_short_repeated_primitives=False,
+                 pointy_brackets=False,
+                 use_index_order=False,
+                 float_format=None,
+                 double_format=None,
+                 use_field_number=False,
+                 descriptor_pool=None,
+                 message_formatter=None,
+                 print_unknown_fields=False,
+                 force_colon=False):
+    printer = _Printer(
+        out=out, indent=indent, as_utf8=as_utf8,
+        as_one_line=as_one_line,
+        use_short_repeated_primitives=use_short_repeated_primitives,
+        pointy_brackets=pointy_brackets,
+        use_index_order=use_index_order,
+        float_format=float_format,
+        double_format=double_format,
+        use_field_number=use_field_number,
+        descriptor_pool=descriptor_pool,
+        message_formatter=message_formatter,
+        print_unknown_fields=print_unknown_fields,
+        force_colon=force_colon)
+    printer.PrintMessage(message)
+
+
+def PrintField(field,
+               value,
+               out,
+               indent=0,
+               as_utf8=False,
+               as_one_line=False,
+               use_short_repeated_primitives=False,
+               pointy_brackets=False,
+               use_index_order=False,
+               float_format=None,
+               double_format=None,
+               message_formatter=None,
+               print_unknown_fields=False,
+               force_colon=False):
+    """Print a single field name/value pair."""
+    printer = _Printer(out, indent, as_utf8, as_one_line,
+                       use_short_repeated_primitives, pointy_brackets,
+                       use_index_order, float_format, double_format,
+                       message_formatter=message_formatter,
+                       print_unknown_fields=print_unknown_fields,
+                       force_colon=force_colon)
+    printer.PrintField(field, value)
+
+
+def PrintFieldValue(field,
+                    value,
+                    out,
+                    indent=0,
+                    as_utf8=False,
+                    as_one_line=False,
+                    use_short_repeated_primitives=False,
+                    pointy_brackets=False,
+                    use_index_order=False,
+                    float_format=None,
+                    double_format=None,
+                    message_formatter=None,
+                    print_unknown_fields=False,
+                    force_colon=False):
+    """Print a single field value (not including name)."""
+    printer = _Printer(out, indent, as_utf8, as_one_line,
+                       use_short_repeated_primitives, pointy_brackets,
+                       use_index_order, float_format, double_format,
+                       message_formatter=message_formatter,
+                       print_unknown_fields=print_unknown_fields,
+                       force_colon=force_colon)
+    printer.PrintFieldValue(field, value)
+
+
+def _BuildMessageFromTypeName(type_name, descriptor_pool):
+    """Returns a protobuf message instance.
+
+    Args:
+      type_name: Fully-qualified protobuf  message type name string.
+      descriptor_pool: DescriptorPool instance.
+
+    Returns:
+      A Message instance of type matching type_name, or None if the a Descriptor
+      wasn't found matching type_name.
+    """
+    # pylint: disable=g-import-not-at-top
+    if descriptor_pool is None:
+        from lark_channel.ws.pb.google.protobuf import descriptor_pool as pool_mod
+        descriptor_pool = pool_mod.Default()
+    from lark_channel.ws.pb.google.protobuf import symbol_database
+    database = symbol_database.Default()
+    try:
+        message_descriptor = descriptor_pool.FindMessageTypeByName(type_name)
+    except KeyError:
+        return None
+    message_type = database.GetPrototype(message_descriptor)
+    return message_type()
+
+
+# These values must match WireType enum in google/protobuf/wire_format.h.
+WIRETYPE_LENGTH_DELIMITED = 2
+WIRETYPE_START_GROUP = 3
+
+
+class _Printer(object):
+    """Text format printer for protocol message."""
+
+    def __init__(
+            self,
+            out,
+            indent=0,
+            as_utf8=False,
+            as_one_line=False,
+            use_short_repeated_primitives=False,
+            pointy_brackets=False,
+            use_index_order=False,
+            float_format=None,
+            double_format=None,
+            use_field_number=False,
+            descriptor_pool=None,
+            message_formatter=None,
+            print_unknown_fields=False,
+            force_colon=False):
+        """Initialize the Printer.
+
+        Double values can be formatted compactly with 15 digits of precision
+        (which is the most that IEEE 754 "double" can guarantee) using
+        double_format='.15g'. To ensure that converting to text and back to a proto
+        will result in an identical value, double_format='.17g' should be used.
+
+        Args:
+          out: To record the text format result.
+          indent: The initial indent level for pretty print.
+          as_utf8: Return unescaped Unicode for non-ASCII characters.
+              In Python 3 actual Unicode characters may appear as is in strings.
+              In Python 2 the return value will be valid UTF-8 rather than ASCII.
+          as_one_line: Don't introduce newlines between fields.
+          use_short_repeated_primitives: Use short repeated format for primitives.
+          pointy_brackets: If True, use angle brackets instead of curly braces for
+            nesting.
+          use_index_order: If True, print fields of a proto message using the order
+            defined in source code instead of the field number. By default, use the
+            field number order.
+          float_format: If set, use this to specify float field formatting
+            (per the "Format Specification Mini-Language"); otherwise, shortest
+            float that has same value in wire will be printed. Also affect double
+            field if double_format is not set but float_format is set.
+          double_format: If set, use this to specify double field formatting
+            (per the "Format Specification Mini-Language"); if it is not set but
+            float_format is set, use float_format. Otherwise, str() is used.
+          use_field_number: If True, print field numbers instead of names.
+          descriptor_pool: A DescriptorPool used to resolve Any types.
+          message_formatter: A function(message, indent, as_one_line): unicode|None
+            to custom format selected sub-messages (usually based on message type).
+            Use to pretty print parts of the protobuf for easier diffing.
+          print_unknown_fields: If True, unknown fields will be printed.
+          force_colon: If set, a colon will be added after the field name even if
+            the field is a proto message.
+        """
+        self.out = out
+        self.indent = indent
+        self.as_utf8 = as_utf8
+        self.as_one_line = as_one_line
+        self.use_short_repeated_primitives = use_short_repeated_primitives
+        self.pointy_brackets = pointy_brackets
+        self.use_index_order = use_index_order
+        self.float_format = float_format
+        if double_format is not None:
+            self.double_format = double_format
+        else:
+            self.double_format = float_format
+        self.use_field_number = use_field_number
+        self.descriptor_pool = descriptor_pool
+        self.message_formatter = message_formatter
+        self.print_unknown_fields = print_unknown_fields
+        self.force_colon = force_colon
+
+    def _TryPrintAsAnyMessage(self, message):
+        """Serializes if message is a google.protobuf.Any field."""
+        if '/' not in message.type_url:
+            return False
+        packed_message = _BuildMessageFromTypeName(message.TypeName(),
+                                                   self.descriptor_pool)
+        if packed_message:
+            packed_message.MergeFromString(message.value)
+            colon = ':' if self.force_colon else ''
+            self.out.write('%s[%s]%s ' % (self.indent * ' ', message.type_url, colon))
+            self._PrintMessageFieldValue(packed_message)
+            self.out.write(' ' if self.as_one_line else '\n')
+            return True
+        else:
+            return False
+
+    def _TryCustomFormatMessage(self, message):
+        formatted = self.message_formatter(message, self.indent, self.as_one_line)
+        if formatted is None:
+            return False
+
+        out = self.out
+        out.write(' ' * self.indent)
+        out.write(formatted)
+        out.write(' ' if self.as_one_line else '\n')
+        return True
+
+    def PrintMessage(self, message):
+        """Convert protobuf message to text format.
+
+        Args:
+          message: The protocol buffers message.
+        """
+        if self.message_formatter and self._TryCustomFormatMessage(message):
+            return
+        if (message.DESCRIPTOR.full_name == _ANY_FULL_TYPE_NAME and
+                self._TryPrintAsAnyMessage(message)):
+            return
+        fields = message.ListFields()
+        if self.use_index_order:
+            fields.sort(
+                key=lambda x: x[0].number if x[0].is_extension else x[0].index)
+        for field, value in fields:
+            if _IsMapEntry(field):
+                for key in sorted(value):
+                    # This is slow for maps with submessage entries because it copies the
+                    # entire tree.  Unfortunately this would take significant refactoring
+                    # of this file to work around.
+                    #
+                    # TODO(haberman): refactor and optimize if this becomes an issue.
+                    entry_submsg = value.GetEntryClass()(key=key, value=value[key])
+                    self.PrintField(field, entry_submsg)
+            elif field.label == descriptor.FieldDescriptor.LABEL_REPEATED:
+                if (self.use_short_repeated_primitives
+                        and field.cpp_type != descriptor.FieldDescriptor.CPPTYPE_MESSAGE
+                        and field.cpp_type != descriptor.FieldDescriptor.CPPTYPE_STRING):
+                    self._PrintShortRepeatedPrimitivesValue(field, value)
+                else:
+                    for element in value:
+                        self.PrintField(field, element)
+            else:
+                self.PrintField(field, value)
+
+        if self.print_unknown_fields:
+            self._PrintUnknownFields(message.UnknownFields())
+
+    def _PrintUnknownFields(self, unknown_fields):
+        """Print unknown fields."""
+        out = self.out
+        for field in unknown_fields:
+            out.write(' ' * self.indent)
+            out.write(str(field.field_number))
+            if field.wire_type == WIRETYPE_START_GROUP:
+                if self.as_one_line:
+                    out.write(' { ')
+                else:
+                    out.write(' {\n')
+                    self.indent += 2
+
+                self._PrintUnknownFields(field.data)
+
+                if self.as_one_line:
+                    out.write('} ')
+                else:
+                    self.indent -= 2
+                    out.write(' ' * self.indent + '}\n')
+            elif field.wire_type == WIRETYPE_LENGTH_DELIMITED:
+                try:
+                    # If this field is parseable as a Message, it is probably
+                    # an embedded message.
+                    # pylint: disable=protected-access
+                    (embedded_unknown_message, pos) = decoder._DecodeUnknownFieldSet(
+                        memoryview(field.data), 0, len(field.data))
+                except Exception:  # pylint: disable=broad-except
+                    pos = 0
+
+                if pos == len(field.data):
+                    if self.as_one_line:
+                        out.write(' { ')
+                    else:
+                        out.write(' {\n')
+                        self.indent += 2
+
+                    self._PrintUnknownFields(embedded_unknown_message)
+
+                    if self.as_one_line:
+                        out.write('} ')
+                    else:
+                        self.indent -= 2
+                        out.write(' ' * self.indent + '}\n')
+                else:
+                    # A string or bytes field. self.as_utf8 may not work.
+                    out.write(': \"')
+                    out.write(text_encoding.CEscape(field.data, False))
+                    out.write('\" ' if self.as_one_line else '\"\n')
+            else:
+                # varint, fixed32, fixed64
+                out.write(': ')
+                out.write(str(field.data))
+                out.write(' ' if self.as_one_line else '\n')
+
+    def _PrintFieldName(self, field):
+        """Print field name."""
+        out = self.out
+        out.write(' ' * self.indent)
+        if self.use_field_number:
+            out.write(str(field.number))
+        else:
+            if field.is_extension:
+                out.write('[')
+                if (field.containing_type.GetOptions().message_set_wire_format and
+                        field.type == descriptor.FieldDescriptor.TYPE_MESSAGE and
+                        field.label == descriptor.FieldDescriptor.LABEL_OPTIONAL):
+                    out.write(field.message_type.full_name)
+                else:
+                    out.write(field.full_name)
+                out.write(']')
+            elif field.type == descriptor.FieldDescriptor.TYPE_GROUP:
+                # For groups, use the capitalized name.
+                out.write(field.message_type.name)
+            else:
+                out.write(field.name)
+
+        if (self.force_colon or
+                field.cpp_type != descriptor.FieldDescriptor.CPPTYPE_MESSAGE):
+            # The colon is optional in this case, but our cross-language golden files
+            # don't include it. Here, the colon is only included if force_colon is
+            # set to True
+            out.write(':')
+
+    def PrintField(self, field, value):
+        """Print a single field name/value pair."""
+        self._PrintFieldName(field)
+        self.out.write(' ')
+        self.PrintFieldValue(field, value)
+        self.out.write(' ' if self.as_one_line else '\n')
+
+    def _PrintShortRepeatedPrimitivesValue(self, field, value):
+        """"Prints short repeated primitives value."""
+        # Note: this is called only when value has at least one element.
+        self._PrintFieldName(field)
+        self.out.write(' [')
+        for i in range(len(value) - 1):
+            self.PrintFieldValue(field, value[i])
+            self.out.write(', ')
+        self.PrintFieldValue(field, value[-1])
+        self.out.write(']')
+        self.out.write(' ' if self.as_one_line else '\n')
+
+    def _PrintMessageFieldValue(self, value):
+        if self.pointy_brackets:
+            openb = '<'
+            closeb = '>'
+        else:
+            openb = '{'
+            closeb = '}'
+
+        if self.as_one_line:
+            self.out.write('%s ' % openb)
+            self.PrintMessage(value)
+            self.out.write(closeb)
+        else:
+            self.out.write('%s\n' % openb)
+            self.indent += 2
+            self.PrintMessage(value)
+            self.indent -= 2
+            self.out.write(' ' * self.indent + closeb)
+
+    def PrintFieldValue(self, field, value):
+        """Print a single field value (not including name).
+
+        For repeated fields, the value should be a single element.
+
+        Args:
+          field: The descriptor of the field to be printed.
+          value: The value of the field.
+        """
+        out = self.out
+        if field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_MESSAGE:
+            self._PrintMessageFieldValue(value)
+        elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_ENUM:
+            enum_value = field.enum_type.values_by_number.get(value, None)
+            if enum_value is not None:
+                out.write(enum_value.name)
+            else:
+                out.write(str(value))
+        elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_STRING:
+            out.write('\"')
+            if isinstance(value, str) and not self.as_utf8:
+                out_value = value.encode('utf-8')
+            else:
+                out_value = value
+            if field.type == descriptor.FieldDescriptor.TYPE_BYTES:
+                # We always need to escape all binary data in TYPE_BYTES fields.
+                out_as_utf8 = False
+            else:
+                out_as_utf8 = self.as_utf8
+            out.write(text_encoding.CEscape(out_value, out_as_utf8))
+            out.write('\"')
+        elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_BOOL:
+            if value:
+                out.write('true')
+            else:
+                out.write('false')
+        elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_FLOAT:
+            if self.float_format is not None:
+                out.write('{1:{0}}'.format(self.float_format, value))
+            else:
+                if math.isnan(value):
+                    out.write(str(value))
+                else:
+                    out.write(str(type_checkers.ToShortestFloat(value)))
+        elif (field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_DOUBLE and
+              self.double_format is not None):
+            out.write('{1:{0}}'.format(self.double_format, value))
+        else:
+            out.write(str(value))
+
+
+def Parse(text,
+          message,
+          allow_unknown_extension=False,
+          allow_field_number=False,
+          descriptor_pool=None,
+          allow_unknown_field=False):
+    """Parses a text representation of a protocol message into a message.
+
+    NOTE: for historical reasons this function does not clear the input
+    message. This is different from what the binary msg.ParseFrom(...) does.
+    If text contains a field already set in message, the value is appended if the
+    field is repeated. Otherwise, an error is raised.
+
+    Example::
+
+      a = MyProto()
+      a.repeated_field.append('test')
+      b = MyProto()
+
+      # Repeated fields are combined
+      text_format.Parse(repr(a), b)
+      text_format.Parse(repr(a), b) # repeated_field contains ["test", "test"]
+
+      # Non-repeated fields cannot be overwritten
+      a.singular_field = 1
+      b.singular_field = 2
+      text_format.Parse(repr(a), b) # ParseError
+
+      # Binary version:
+      b.ParseFromString(a.SerializeToString()) # repeated_field is now "test"
+
+    Caller is responsible for clearing the message as needed.
+
+    Args:
+      text (str): Message text representation.
+      message (Message): A protocol buffer message to merge into.
+      allow_unknown_extension: if True, skip over missing extensions and keep
+        parsing
+      allow_field_number: if True, both field number and field name are allowed.
+      descriptor_pool (DescriptorPool): Descriptor pool used to resolve Any types.
+      allow_unknown_field: if True, skip over unknown field and keep
+        parsing. Avoid to use this option if possible. It may hide some
+        errors (e.g. spelling error on field name)
+
+    Returns:
+      Message: The same message passed as argument.
+
+    Raises:
+      ParseError: On text parsing problems.
+    """
+    return ParseLines(text.split(b'\n' if isinstance(text, bytes) else u'\n'),
+                      message,
+                      allow_unknown_extension,
+                      allow_field_number,
+                      descriptor_pool=descriptor_pool,
+                      allow_unknown_field=allow_unknown_field)
+
+
+def Merge(text,
+          message,
+          allow_unknown_extension=False,
+          allow_field_number=False,
+          descriptor_pool=None,
+          allow_unknown_field=False):
+    """Parses a text representation of a protocol message into a message.
+
+    Like Parse(), but allows repeated values for a non-repeated field, and uses
+    the last one. This means any non-repeated, top-level fields specified in text
+    replace those in the message.
+
+    Args:
+      text (str): Message text representation.
+      message (Message): A protocol buffer message to merge into.
+      allow_unknown_extension: if True, skip over missing extensions and keep
+        parsing
+      allow_field_number: if True, both field number and field name are allowed.
+      descriptor_pool (DescriptorPool): Descriptor pool used to resolve Any types.
+      allow_unknown_field: if True, skip over unknown field and keep
+        parsing. Avoid to use this option if possible. It may hide some
+        errors (e.g. spelling error on field name)
+
+    Returns:
+      Message: The same message passed as argument.
+
+    Raises:
+      ParseError: On text parsing problems.
+    """
+    return MergeLines(
+        text.split(b'\n' if isinstance(text, bytes) else u'\n'),
+        message,
+        allow_unknown_extension,
+        allow_field_number,
+        descriptor_pool=descriptor_pool,
+        allow_unknown_field=allow_unknown_field)
+
+
+def ParseLines(lines,
+               message,
+               allow_unknown_extension=False,
+               allow_field_number=False,
+               descriptor_pool=None,
+               allow_unknown_field=False):
+    """Parses a text representation of a protocol message into a message.
+
+    See Parse() for caveats.
+
+    Args:
+      lines: An iterable of lines of a message's text representation.
+      message: A protocol buffer message to merge into.
+      allow_unknown_extension: if True, skip over missing extensions and keep
+        parsing
+      allow_field_number: if True, both field number and field name are allowed.
+      descriptor_pool: A DescriptorPool used to resolve Any types.
+      allow_unknown_field: if True, skip over unknown field and keep
+        parsing. Avoid to use this option if possible. It may hide some
+        errors (e.g. spelling error on field name)
+
+    Returns:
+      The same message passed as argument.
+
+    Raises:
+      ParseError: On text parsing problems.
+    """
+    parser = _Parser(allow_unknown_extension,
+                     allow_field_number,
+                     descriptor_pool=descriptor_pool,
+                     allow_unknown_field=allow_unknown_field)
+    return parser.ParseLines(lines, message)
+
+
+def MergeLines(lines,
+               message,
+               allow_unknown_extension=False,
+               allow_field_number=False,
+               descriptor_pool=None,
+               allow_unknown_field=False):
+    """Parses a text representation of a protocol message into a message.
+
+    See Merge() for more details.
+
+    Args:
+      lines: An iterable of lines of a message's text representation.
+      message: A protocol buffer message to merge into.
+      allow_unknown_extension: if True, skip over missing extensions and keep
+        parsing
+      allow_field_number: if True, both field number and field name are allowed.
+      descriptor_pool: A DescriptorPool used to resolve Any types.
+      allow_unknown_field: if True, skip over unknown field and keep
+        parsing. Avoid to use this option if possible. It may hide some
+        errors (e.g. spelling error on field name)
+
+    Returns:
+      The same message passed as argument.
+
+    Raises:
+      ParseError: On text parsing problems.
+    """
+    parser = _Parser(allow_unknown_extension,
+                     allow_field_number,
+                     descriptor_pool=descriptor_pool,
+                     allow_unknown_field=allow_unknown_field)
+    return parser.MergeLines(lines, message)
+
+
+class _Parser(object):
+    """Text format parser for protocol message."""
+
+    def __init__(self,
+                 allow_unknown_extension=False,
+                 allow_field_number=False,
+                 descriptor_pool=None,
+                 allow_unknown_field=False):
+        self.allow_unknown_extension = allow_unknown_extension
+        self.allow_field_number = allow_field_number
+        self.descriptor_pool = descriptor_pool
+        self.allow_unknown_field = allow_unknown_field
+
+    def ParseLines(self, lines, message):
+        """Parses a text representation of a protocol message into a message."""
+        self._allow_multiple_scalars = False
+        self._ParseOrMerge(lines, message)
+        return message
+
+    def MergeLines(self, lines, message):
+        """Merges a text representation of a protocol message into a message."""
+        self._allow_multiple_scalars = True
+        self._ParseOrMerge(lines, message)
+        return message
+
+    def _ParseOrMerge(self, lines, message):
+        """Converts a text representation of a protocol message into a message.
+
+        Args:
+          lines: Lines of a message's text representation.
+          message: A protocol buffer message to merge into.
+
+        Raises:
+          ParseError: On text parsing problems.
+        """
+        # Tokenize expects native str lines.
+        str_lines = (
+            line if isinstance(line, str) else line.decode('utf-8')
+            for line in lines)
+        tokenizer = Tokenizer(str_lines)
+        while not tokenizer.AtEnd():
+            self._MergeField(tokenizer, message)
+
+    def _MergeField(self, tokenizer, message):
+        """Merges a single protocol message field into a message.
+
+        Args:
+          tokenizer: A tokenizer to parse the field name and values.
+          message: A protocol message to record the data.
+
+        Raises:
+          ParseError: In case of text parsing problems.
+        """
+        message_descriptor = message.DESCRIPTOR
+        if (message_descriptor.full_name == _ANY_FULL_TYPE_NAME and
+                tokenizer.TryConsume('[')):
+            type_url_prefix, packed_type_name = self._ConsumeAnyTypeUrl(tokenizer)
+            tokenizer.Consume(']')
+            tokenizer.TryConsume(':')
+            if tokenizer.TryConsume('<'):
+                expanded_any_end_token = '>'
+            else:
+                tokenizer.Consume('{')
+                expanded_any_end_token = '}'
+            expanded_any_sub_message = _BuildMessageFromTypeName(packed_type_name,
+                                                                 self.descriptor_pool)
+            if not expanded_any_sub_message:
+                raise ParseError('Type %s not found in descriptor pool' %
+                                 packed_type_name)
+            while not tokenizer.TryConsume(expanded_any_end_token):
+                if tokenizer.AtEnd():
+                    raise tokenizer.ParseErrorPreviousToken('Expected "%s".' %
+                                                            (expanded_any_end_token,))
+                self._MergeField(tokenizer, expanded_any_sub_message)
+            deterministic = False
+
+            message.Pack(expanded_any_sub_message,
+                         type_url_prefix=type_url_prefix,
+                         deterministic=deterministic)
+            return
+
+        if tokenizer.TryConsume('['):
+            name = [tokenizer.ConsumeIdentifier()]
+            while tokenizer.TryConsume('.'):
+                name.append(tokenizer.ConsumeIdentifier())
+            name = '.'.join(name)
+
+            if not message_descriptor.is_extendable:
+                raise tokenizer.ParseErrorPreviousToken(
+                    'Message type "%s" does not have extensions.' %
+                    message_descriptor.full_name)
+            # pylint: disable=protected-access
+            field = message.Extensions._FindExtensionByName(name)
+            # pylint: enable=protected-access
+
+            if not field:
+                if self.allow_unknown_extension:
+                    field = None
+                else:
+                    raise tokenizer.ParseErrorPreviousToken(
+                        'Extension "%s" not registered. '
+                        'Did you import the _pb2 module which defines it? '
+                        'If you are trying to place the extension in the MessageSet '
+                        'field of another message that is in an Any or MessageSet field, '
+                        'that message\'s _pb2 module must be imported as well' % name)
+            elif message_descriptor != field.containing_type:
+                raise tokenizer.ParseErrorPreviousToken(
+                    'Extension "%s" does not extend message type "%s".' %
+                    (name, message_descriptor.full_name))
+
+            tokenizer.Consume(']')
+
+        else:
+            name = tokenizer.ConsumeIdentifierOrNumber()
+            if self.allow_field_number and name.isdigit():
+                number = ParseInteger(name, True, True)
+                field = message_descriptor.fields_by_number.get(number, None)
+                if not field and message_descriptor.is_extendable:
+                    field = message.Extensions._FindExtensionByNumber(number)
+            else:
+                field = message_descriptor.fields_by_name.get(name, None)
+
+                # Group names are expected to be capitalized as they appear in the
+                # .proto file, which actually matches their type names, not their field
+                # names.
+                if not field:
+                    field = message_descriptor.fields_by_name.get(name.lower(), None)
+                    if field and field.type != descriptor.FieldDescriptor.TYPE_GROUP:
+                        field = None
+
+                if (field and field.type == descriptor.FieldDescriptor.TYPE_GROUP and
+                        field.message_type.name != name):
+                    field = None
+
+            if not field and not self.allow_unknown_field:
+                raise tokenizer.ParseErrorPreviousToken(
+                    'Message type "%s" has no field named "%s".' %
+                    (message_descriptor.full_name, name))
+
+        if field:
+            if not self._allow_multiple_scalars and field.containing_oneof:
+                # Check if there's a different field set in this oneof.
+                # Note that we ignore the case if the same field was set before, and we
+                # apply _allow_multiple_scalars to non-scalar fields as well.
+                which_oneof = message.WhichOneof(field.containing_oneof.name)
+                if which_oneof is not None and which_oneof != field.name:
+                    raise tokenizer.ParseErrorPreviousToken(
+                        'Field "%s" is specified along with field "%s", another member '
+                        'of oneof "%s" for message type "%s".' %
+                        (field.name, which_oneof, field.containing_oneof.name,
+                         message_descriptor.full_name))
+
+            if field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_MESSAGE:
+                tokenizer.TryConsume(':')
+                merger = self._MergeMessageField
+            else:
+                tokenizer.Consume(':')
+                merger = self._MergeScalarField
+
+            if (field.label == descriptor.FieldDescriptor.LABEL_REPEATED and
+                    tokenizer.TryConsume('[')):
+                # Short repeated format, e.g. "foo: [1, 2, 3]"
+                if not tokenizer.TryConsume(']'):
+                    while True:
+                        merger(tokenizer, message, field)
+                        if tokenizer.TryConsume(']'):
+                            break
+                        tokenizer.Consume(',')
+
+            else:
+                merger(tokenizer, message, field)
+
+        else:  # Proto field is unknown.
+            assert (self.allow_unknown_extension or self.allow_unknown_field)
+            _SkipFieldContents(tokenizer)
+
+        # For historical reasons, fields may optionally be separated by commas or
+        # semicolons.
+        if not tokenizer.TryConsume(','):
+            tokenizer.TryConsume(';')
+
+    def _ConsumeAnyTypeUrl(self, tokenizer):
+        """Consumes a google.protobuf.Any type URL and returns the type name."""
+        # Consume "type.googleapis.com/".
+        prefix = [tokenizer.ConsumeIdentifier()]
+        tokenizer.Consume('.')
+        prefix.append(tokenizer.ConsumeIdentifier())
+        tokenizer.Consume('.')
+        prefix.append(tokenizer.ConsumeIdentifier())
+        tokenizer.Consume('/')
+        # Consume the fully-qualified type name.
+        name = [tokenizer.ConsumeIdentifier()]
+        while tokenizer.TryConsume('.'):
+            name.append(tokenizer.ConsumeIdentifier())
+        return '.'.join(prefix), '.'.join(name)
+
+    def _MergeMessageField(self, tokenizer, message, field):
+        """Merges a single scalar field into a message.
+
+        Args:
+          tokenizer: A tokenizer to parse the field value.
+          message: The message of which field is a member.
+          field: The descriptor of the field to be merged.
+
+        Raises:
+          ParseError: In case of text parsing problems.
+        """
+        is_map_entry = _IsMapEntry(field)
+
+        if tokenizer.TryConsume('<'):
+            end_token = '>'
+        else:
+            tokenizer.Consume('{')
+            end_token = '}'
+
+        if field.label == descriptor.FieldDescriptor.LABEL_REPEATED:
+            if field.is_extension:
+                sub_message = message.Extensions[field].add()
+            elif is_map_entry:
+                sub_message = getattr(message, field.name).GetEntryClass()()
+            else:
+                sub_message = getattr(message, field.name).add()
+        else:
+            if field.is_extension:
+                if (not self._allow_multiple_scalars and
+                        message.HasExtension(field)):
+                    raise tokenizer.ParseErrorPreviousToken(
+                        'Message type "%s" should not have multiple "%s" extensions.' %
+                        (message.DESCRIPTOR.full_name, field.full_name))
+                sub_message = message.Extensions[field]
+            else:
+                # Also apply _allow_multiple_scalars to message field.
+                # TODO(jieluo): Change to _allow_singular_overwrites.
+                if (not self._allow_multiple_scalars and
+                        message.HasField(field.name)):
+                    raise tokenizer.ParseErrorPreviousToken(
+                        'Message type "%s" should not have multiple "%s" fields.' %
+                        (message.DESCRIPTOR.full_name, field.name))
+                sub_message = getattr(message, field.name)
+            sub_message.SetInParent()
+
+        while not tokenizer.TryConsume(end_token):
+            if tokenizer.AtEnd():
+                raise tokenizer.ParseErrorPreviousToken('Expected "%s".' % (end_token,))
+            self._MergeField(tokenizer, sub_message)
+
+        if is_map_entry:
+            value_cpptype = field.message_type.fields_by_name['value'].cpp_type
+            if value_cpptype == descriptor.FieldDescriptor.CPPTYPE_MESSAGE:
+                value = getattr(message, field.name)[sub_message.key]
+                value.CopyFrom(sub_message.value)
+            else:
+                getattr(message, field.name)[sub_message.key] = sub_message.value
+
+    @staticmethod
+    def _IsProto3Syntax(message):
+        message_descriptor = message.DESCRIPTOR
+        return (hasattr(message_descriptor, 'syntax') and
+                message_descriptor.syntax == 'proto3')
+
+    def _MergeScalarField(self, tokenizer, message, field):
+        """Merges a single scalar field into a message.
+
+        Args:
+          tokenizer: A tokenizer to parse the field value.
+          message: A protocol message to record the data.
+          field: The descriptor of the field to be merged.
+
+        Raises:
+          ParseError: In case of text parsing problems.
+          RuntimeError: On runtime errors.
+        """
+        _ = self.allow_unknown_extension
+        value = None
+
+        if field.type in (descriptor.FieldDescriptor.TYPE_INT32,
+                          descriptor.FieldDescriptor.TYPE_SINT32,
+                          descriptor.FieldDescriptor.TYPE_SFIXED32):
+            value = _ConsumeInt32(tokenizer)
+        elif field.type in (descriptor.FieldDescriptor.TYPE_INT64,
+                            descriptor.FieldDescriptor.TYPE_SINT64,
+                            descriptor.FieldDescriptor.TYPE_SFIXED64):
+            value = _ConsumeInt64(tokenizer)
+        elif field.type in (descriptor.FieldDescriptor.TYPE_UINT32,
+                            descriptor.FieldDescriptor.TYPE_FIXED32):
+            value = _ConsumeUint32(tokenizer)
+        elif field.type in (descriptor.FieldDescriptor.TYPE_UINT64,
+                            descriptor.FieldDescriptor.TYPE_FIXED64):
+            value = _ConsumeUint64(tokenizer)
+        elif field.type in (descriptor.FieldDescriptor.TYPE_FLOAT,
+                            descriptor.FieldDescriptor.TYPE_DOUBLE):
+            value = tokenizer.ConsumeFloat()
+        elif field.type == descriptor.FieldDescriptor.TYPE_BOOL:
+            value = tokenizer.ConsumeBool()
+        elif field.type == descriptor.FieldDescriptor.TYPE_STRING:
+            value = tokenizer.ConsumeString()
+        elif field.type == descriptor.FieldDescriptor.TYPE_BYTES:
+            value = tokenizer.ConsumeByteString()
+        elif field.type == descriptor.FieldDescriptor.TYPE_ENUM:
+            value = tokenizer.ConsumeEnum(field)
+        else:
+            raise RuntimeError('Unknown field type %d' % field.type)
+
+        if field.label == descriptor.FieldDescriptor.LABEL_REPEATED:
+            if field.is_extension:
+                message.Extensions[field].append(value)
+            else:
+                getattr(message, field.name).append(value)
+        else:
+            if field.is_extension:
+                if (not self._allow_multiple_scalars and
+                        not self._IsProto3Syntax(message) and
+                        message.HasExtension(field)):
+                    raise tokenizer.ParseErrorPreviousToken(
+                        'Message type "%s" should not have multiple "%s" extensions.' %
+                        (message.DESCRIPTOR.full_name, field.full_name))
+                else:
+                    message.Extensions[field] = value
+            else:
+                duplicate_error = False
+                if not self._allow_multiple_scalars:
+                    if self._IsProto3Syntax(message):
+                        # Proto3 doesn't represent presence so we try best effort to check
+                        # multiple scalars by compare to default values.
+                        duplicate_error = bool(getattr(message, field.name))
+                    else:
+                        duplicate_error = message.HasField(field.name)
+
+                if duplicate_error:
+                    raise tokenizer.ParseErrorPreviousToken(
+                        'Message type "%s" should not have multiple "%s" fields.' %
+                        (message.DESCRIPTOR.full_name, field.name))
+                else:
+                    setattr(message, field.name, value)
+
+
+def _SkipFieldContents(tokenizer):
+    """Skips over contents (value or message) of a field.
+
+    Args:
+      tokenizer: A tokenizer to parse the field name and values.
+    """
+    # Try to guess the type of this field.
+    # If this field is not a message, there should be a ":" between the
+    # field name and the field value and also the field value should not
+    # start with "{" or "<" which indicates the beginning of a message body.
+    # If there is no ":" or there is a "{" or "<" after ":", this field has
+    # to be a message or the input is ill-formed.
+    if tokenizer.TryConsume(':') and not tokenizer.LookingAt(
+            '{') and not tokenizer.LookingAt('<'):
+        _SkipFieldValue(tokenizer)
+    else:
+        _SkipFieldMessage(tokenizer)
+
+
+def _SkipField(tokenizer):
+    """Skips over a complete field (name and value/message).
+
+    Args:
+      tokenizer: A tokenizer to parse the field name and values.
+    """
+    if tokenizer.TryConsume('['):
+        # Consume extension name.
+        tokenizer.ConsumeIdentifier()
+        while tokenizer.TryConsume('.'):
+            tokenizer.ConsumeIdentifier()
+        tokenizer.Consume(']')
+    else:
+        tokenizer.ConsumeIdentifierOrNumber()
+
+    _SkipFieldContents(tokenizer)
+
+    # For historical reasons, fields may optionally be separated by commas or
+    # semicolons.
+    if not tokenizer.TryConsume(','):
+        tokenizer.TryConsume(';')
+
+
+def _SkipFieldMessage(tokenizer):
+    """Skips over a field message.
+
+    Args:
+      tokenizer: A tokenizer to parse the field name and values.
+    """
+
+    if tokenizer.TryConsume('<'):
+        delimiter = '>'
+    else:
+        tokenizer.Consume('{')
+        delimiter = '}'
+
+    while not tokenizer.LookingAt('>') and not tokenizer.LookingAt('}'):
+        _SkipField(tokenizer)
+
+    tokenizer.Consume(delimiter)
+
+
+def _SkipFieldValue(tokenizer):
+    """Skips over a field value.
+
+    Args:
+      tokenizer: A tokenizer to parse the field name and values.
+
+    Raises:
+      ParseError: In case an invalid field value is found.
+    """
+    # String/bytes tokens can come in multiple adjacent string literals.
+    # If we can consume one, consume as many as we can.
+    if tokenizer.TryConsumeByteString():
+        while tokenizer.TryConsumeByteString():
+            pass
+        return
+
+    if (not tokenizer.TryConsumeIdentifier() and
+            not _TryConsumeInt64(tokenizer) and not _TryConsumeUint64(tokenizer) and
+            not tokenizer.TryConsumeFloat()):
+        raise ParseError('Invalid field value: ' + tokenizer.token)
+
+
+class Tokenizer(object):
+    """Protocol buffer text representation tokenizer.
+
+    This class handles the lower level string parsing by splitting it into
+    meaningful tokens.
+
+    It was directly ported from the Java protocol buffer API.
+    """
+
+    _WHITESPACE = re.compile(r'\s+')
+    _COMMENT = re.compile(r'(\s*#.*$)', re.MULTILINE)
+    _WHITESPACE_OR_COMMENT = re.compile(r'(\s|(#.*$))+', re.MULTILINE)
+    _TOKEN = re.compile('|'.join([
+                                     r'[a-zA-Z_][0-9a-zA-Z_+-]*',  # an identifier
+                                     r'([0-9+-]|(\.[0-9]))[0-9a-zA-Z_.+-]*',  # a number
+                                 ] + [  # quoted str for each quote mark
+                                     # Avoid backtracking! https://stackoverflow.com/a/844267
+                                     r'{qt}[^{qt}\n\\]*((\\.)+[^{qt}\n\\]*)*({qt}|\\?$)'.format(qt=mark)
+                                     for mark in _QUOTES
+                                 ]))
+
+    _IDENTIFIER = re.compile(r'[^\d\W]\w*')
+    _IDENTIFIER_OR_NUMBER = re.compile(r'\w+')
+
+    def __init__(self, lines, skip_comments=True):
+        self._position = 0
+        self._line = -1
+        self._column = 0
+        self._token_start = None
+        self.token = ''
+        self._lines = iter(lines)
+        self._current_line = ''
+        self._previous_line = 0
+        self._previous_column = 0
+        self._more_lines = True
+        self._skip_comments = skip_comments
+        self._whitespace_pattern = (skip_comments and self._WHITESPACE_OR_COMMENT
+                                    or self._WHITESPACE)
+        self._SkipWhitespace()
+        self.NextToken()
+
+    def LookingAt(self, token):
+        return self.token == token
+
+    def AtEnd(self):
+        """Checks the end of the text was reached.
+
+        Returns:
+          True iff the end was reached.
+        """
+        return not self.token
+
+    def _PopLine(self):
+        while len(self._current_line) <= self._column:
+            try:
+                self._current_line = next(self._lines)
+            except StopIteration:
+                self._current_line = ''
+                self._more_lines = False
+                return
+            else:
+                self._line += 1
+                self._column = 0
+
+    def _SkipWhitespace(self):
+        while True:
+            self._PopLine()
+            match = self._whitespace_pattern.match(self._current_line, self._column)
+            if not match:
+                break
+            length = len(match.group(0))
+            self._column += length
+
+    def TryConsume(self, token):
+        """Tries to consume a given piece of text.
+
+        Args:
+          token: Text to consume.
+
+        Returns:
+          True iff the text was consumed.
+        """
+        if self.token == token:
+            self.NextToken()
+            return True
+        return False
+
+    def Consume(self, token):
+        """Consumes a piece of text.
+
+        Args:
+          token: Text to consume.
+
+        Raises:
+          ParseError: If the text couldn't be consumed.
+        """
+        if not self.TryConsume(token):
+            raise self.ParseError('Expected "%s".' % token)
+
+    def ConsumeComment(self):
+        result = self.token
+        if not self._COMMENT.match(result):
+            raise self.ParseError('Expected comment.')
+        self.NextToken()
+        return result
+
+    def ConsumeCommentOrTrailingComment(self):
+        """Consumes a comment, returns a 2-tuple (trailing bool, comment str)."""
+
+        # Tokenizer initializes _previous_line and _previous_column to 0. As the
+        # tokenizer starts, it looks like there is a previous token on the line.
+        just_started = self._line == 0 and self._column == 0
+
+        before_parsing = self._previous_line
+        comment = self.ConsumeComment()
+
+        # A trailing comment is a comment on the same line than the previous token.
+        trailing = (self._previous_line == before_parsing
+                    and not just_started)
+
+        return trailing, comment
+
+    def TryConsumeIdentifier(self):
+        try:
+            self.ConsumeIdentifier()
+            return True
+        except ParseError:
+            return False
+
+    def ConsumeIdentifier(self):
+        """Consumes protocol message field identifier.
+
+        Returns:
+          Identifier string.
+
+        Raises:
+          ParseError: If an identifier couldn't be consumed.
+        """
+        result = self.token
+        if not self._IDENTIFIER.match(result):
+            raise self.ParseError('Expected identifier.')
+        self.NextToken()
+        return result
+
+    def TryConsumeIdentifierOrNumber(self):
+        try:
+            self.ConsumeIdentifierOrNumber()
+            return True
+        except ParseError:
+            return False
+
+    def ConsumeIdentifierOrNumber(self):
+        """Consumes protocol message field identifier.
+
+        Returns:
+          Identifier string.
+
+        Raises:
+          ParseError: If an identifier couldn't be consumed.
+        """
+        result = self.token
+        if not self._IDENTIFIER_OR_NUMBER.match(result):
+            raise self.ParseError('Expected identifier or number, got %s.' % result)
+        self.NextToken()
+        return result
+
+    def TryConsumeInteger(self):
+        try:
+            self.ConsumeInteger()
+            return True
+        except ParseError:
+            return False
+
+    def ConsumeInteger(self):
+        """Consumes an integer number.
+
+        Returns:
+          The integer parsed.
+
+        Raises:
+          ParseError: If an integer couldn't be consumed.
+        """
+        try:
+            result = _ParseAbstractInteger(self.token)
+        except ValueError as e:
+            raise self.ParseError(str(e))
+        self.NextToken()
+        return result
+
+    def TryConsumeFloat(self):
+        try:
+            self.ConsumeFloat()
+            return True
+        except ParseError:
+            return False
+
+    def ConsumeFloat(self):
+        """Consumes an floating point number.
+
+        Returns:
+          The number parsed.
+
+        Raises:
+          ParseError: If a floating point number couldn't be consumed.
+        """
+        try:
+            result = ParseFloat(self.token)
+        except ValueError as e:
+            raise self.ParseError(str(e))
+        self.NextToken()
+        return result
+
+    def ConsumeBool(self):
+        """Consumes a boolean value.
+
+        Returns:
+          The bool parsed.
+
+        Raises:
+          ParseError: If a boolean value couldn't be consumed.
+        """
+        try:
+            result = ParseBool(self.token)
+        except ValueError as e:
+            raise self.ParseError(str(e))
+        self.NextToken()
+        return result
+
+    def TryConsumeByteString(self):
+        try:
+            self.ConsumeByteString()
+            return True
+        except ParseError:
+            return False
+
+    def ConsumeString(self):
+        """Consumes a string value.
+
+        Returns:
+          The string parsed.
+
+        Raises:
+          ParseError: If a string value couldn't be consumed.
+        """
+        the_bytes = self.ConsumeByteString()
+        try:
+            return str(the_bytes, 'utf-8')
+        except UnicodeDecodeError as e:
+            raise self._StringParseError(e)
+
+    def ConsumeByteString(self):
+        """Consumes a byte array value.
+
+        Returns:
+          The array parsed (as a string).
+
+        Raises:
+          ParseError: If a byte array value couldn't be consumed.
+        """
+        the_list = [self._ConsumeSingleByteString()]
+        while self.token and self.token[0] in _QUOTES:
+            the_list.append(self._ConsumeSingleByteString())
+        return b''.join(the_list)
+
+    def _ConsumeSingleByteString(self):
+        """Consume one token of a string literal.
+
+        String literals (whether bytes or text) can come in multiple adjacent
+        tokens which are automatically concatenated, like in C or Python.  This
+        method only consumes one token.
+
+        Returns:
+          The token parsed.
+        Raises:
+          ParseError: When the wrong format data is found.
+        """
+        text = self.token
+        if len(text) < 1 or text[0] not in _QUOTES:
+            raise self.ParseError('Expected string but found: %r' % (text,))
+
+        if len(text) < 2 or text[-1] != text[0]:
+            raise self.ParseError('String missing ending quote: %r' % (text,))
+
+        try:
+            result = text_encoding.CUnescape(text[1:-1])
+        except ValueError as e:
+            raise self.ParseError(str(e))
+        self.NextToken()
+        return result
+
+    def ConsumeEnum(self, field):
+        try:
+            result = ParseEnum(field, self.token)
+        except ValueError as e:
+            raise self.ParseError(str(e))
+        self.NextToken()
+        return result
+
+    def ParseErrorPreviousToken(self, message):
+        """Creates and *returns* a ParseError for the previously read token.
+
+        Args:
+          message: A message to set for the exception.
+
+        Returns:
+          A ParseError instance.
+        """
+        return ParseError(message, self._previous_line + 1,
+                          self._previous_column + 1)
+
+    def ParseError(self, message):
+        """Creates and *returns* a ParseError for the current token."""
+        return ParseError('\'' + self._current_line + '\': ' + message,
+                          self._line + 1, self._column + 1)
+
+    def _StringParseError(self, e):
+        return self.ParseError('Couldn\'t parse string: ' + str(e))
+
+    def NextToken(self):
+        """Reads the next meaningful token."""
+        self._previous_line = self._line
+        self._previous_column = self._column
+
+        self._column += len(self.token)
+        self._SkipWhitespace()
+
+        if not self._more_lines:
+            self.token = ''
+            return
+
+        match = self._TOKEN.match(self._current_line, self._column)
+        if not match and not self._skip_comments:
+            match = self._COMMENT.match(self._current_line, self._column)
+        if match:
+            token = match.group(0)
+            self.token = token
+        else:
+            self.token = self._current_line[self._column]
+
+
+# Aliased so it can still be accessed by current visibility violators.
+# TODO(dbarnett): Migrate violators to textformat_tokenizer.
+_Tokenizer = Tokenizer  # pylint: disable=invalid-name
+
+
+def _ConsumeInt32(tokenizer):
+    """Consumes a signed 32bit integer number from tokenizer.
+
+    Args:
+      tokenizer: A tokenizer used to parse the number.
+
+    Returns:
+      The integer parsed.
+
+    Raises:
+      ParseError: If a signed 32bit integer couldn't be consumed.
+    """
+    return _ConsumeInteger(tokenizer, is_signed=True, is_long=False)
+
+
+def _ConsumeUint32(tokenizer):
+    """Consumes an unsigned 32bit integer number from tokenizer.
+
+    Args:
+      tokenizer: A tokenizer used to parse the number.
+
+    Returns:
+      The integer parsed.
+
+    Raises:
+      ParseError: If an unsigned 32bit integer couldn't be consumed.
+    """
+    return _ConsumeInteger(tokenizer, is_signed=False, is_long=False)
+
+
+def _TryConsumeInt64(tokenizer):
+    try:
+        _ConsumeInt64(tokenizer)
+        return True
+    except ParseError:
+        return False
+
+
+def _ConsumeInt64(tokenizer):
+    """Consumes a signed 32bit integer number from tokenizer.
+
+    Args:
+      tokenizer: A tokenizer used to parse the number.
+
+    Returns:
+      The integer parsed.
+
+    Raises:
+      ParseError: If a signed 32bit integer couldn't be consumed.
+    """
+    return _ConsumeInteger(tokenizer, is_signed=True, is_long=True)
+
+
+def _TryConsumeUint64(tokenizer):
+    try:
+        _ConsumeUint64(tokenizer)
+        return True
+    except ParseError:
+        return False
+
+
+def _ConsumeUint64(tokenizer):
+    """Consumes an unsigned 64bit integer number from tokenizer.
+
+    Args:
+      tokenizer: A tokenizer used to parse the number.
+
+    Returns:
+      The integer parsed.
+
+    Raises:
+      ParseError: If an unsigned 64bit integer couldn't be consumed.
+    """
+    return _ConsumeInteger(tokenizer, is_signed=False, is_long=True)
+
+
+def _ConsumeInteger(tokenizer, is_signed=False, is_long=False):
+    """Consumes an integer number from tokenizer.
+
+    Args:
+      tokenizer: A tokenizer used to parse the number.
+      is_signed: True if a signed integer must be parsed.
+      is_long: True if a long integer must be parsed.
+
+    Returns:
+      The integer parsed.
+
+    Raises:
+      ParseError: If an integer with given characteristics couldn't be consumed.
+    """
+    try:
+        result = ParseInteger(tokenizer.token, is_signed=is_signed, is_long=is_long)
+    except ValueError as e:
+        raise tokenizer.ParseError(str(e))
+    tokenizer.NextToken()
+    return result
+
+
+def ParseInteger(text, is_signed=False, is_long=False):
+    """Parses an integer.
+
+    Args:
+      text: The text to parse.
+      is_signed: True if a signed integer must be parsed.
+      is_long: True if a long integer must be parsed.
+
+    Returns:
+      The integer value.
+
+    Raises:
+      ValueError: Thrown Iff the text is not a valid integer.
+    """
+    # Do the actual parsing. Exception handling is propagated to caller.
+    result = _ParseAbstractInteger(text)
+
+    # Check if the integer is sane. Exceptions handled by callers.
+    checker = _INTEGER_CHECKERS[2 * int(is_long) + int(is_signed)]
+    checker.CheckValue(result)
+    return result
+
+
+def _ParseAbstractInteger(text):
+    """Parses an integer without checking size/signedness.
+
+    Args:
+      text: The text to parse.
+
+    Returns:
+      The integer value.
+
+    Raises:
+      ValueError: Thrown Iff the text is not a valid integer.
+    """
+    # Do the actual parsing. Exception handling is propagated to caller.
+    orig_text = text
+    c_octal_match = re.match(r'(-?)0(\d+)$', text)
+    if c_octal_match:
+        # Python 3 no longer supports 0755 octal syntax without the 'o', so
+        # we always use the '0o' prefix for multi-digit numbers starting with 0.
+        text = c_octal_match.group(1) + '0o' + c_octal_match.group(2)
+    try:
+        return int(text, 0)
+    except ValueError:
+        raise ValueError('Couldn\'t parse integer: %s' % orig_text)
+
+
+def ParseFloat(text):
+    """Parse a floating point number.
+
+    Args:
+      text: Text to parse.
+
+    Returns:
+      The number parsed.
+
+    Raises:
+      ValueError: If a floating point number couldn't be parsed.
+    """
+    try:
+        # Assume Python compatible syntax.
+        return float(text)
+    except ValueError:
+        # Check alternative spellings.
+        if _FLOAT_INFINITY.match(text):
+            if text[0] == '-':
+                return float('-inf')
+            else:
+                return float('inf')
+        elif _FLOAT_NAN.match(text):
+            return float('nan')
+        else:
+            # assume '1.0f' format
+            try:
+                return float(text.rstrip('f'))
+            except ValueError:
+                raise ValueError('Couldn\'t parse float: %s' % text)
+
+
+def ParseBool(text):
+    """Parse a boolean value.
+
+    Args:
+      text: Text to parse.
+
+    Returns:
+      Boolean values parsed
+
+    Raises:
+      ValueError: If text is not a valid boolean.
+    """
+    if text in ('true', 't', '1', 'True'):
+        return True
+    elif text in ('false', 'f', '0', 'False'):
+        return False
+    else:
+        raise ValueError('Expected "true" or "false".')
+
+
+def ParseEnum(field, value):
+    """Parse an enum value.
+
+    The value can be specified by a number (the enum value), or by
+    a string literal (the enum name).
+
+    Args:
+      field: Enum field descriptor.
+      value: String value.
+
+    Returns:
+      Enum value number.
+
+    Raises:
+      ValueError: If the enum value could not be parsed.
+    """
+    enum_descriptor = field.enum_type
+    try:
+        number = int(value, 0)
+    except ValueError:
+        # Identifier.
+        enum_value = enum_descriptor.values_by_name.get(value, None)
+        if enum_value is None:
+            raise ValueError('Enum type "%s" has no value named %s.' %
+                             (enum_descriptor.full_name, value))
+    else:
+        # Numeric value.
+        if hasattr(field.file, 'syntax'):
+            # Attribute is checked for compatibility.
+            if field.file.syntax == 'proto3':
+                # Proto3 accept numeric unknown enums.
+                return number
+        enum_value = enum_descriptor.values_by_number.get(number, None)
+        if enum_value is None:
+            raise ValueError('Enum type "%s" has no value with number %d.' %
+                             (enum_descriptor.full_name, number))
+    return enum_value.number
diff --git a/lark_channel/ws/pb/google/protobuf/timestamp_pb2.py b/lark_channel/ws/pb/google/protobuf/timestamp_pb2.py
new file mode 100644
index 0000000..6be628e
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/timestamp_pb2.py
@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+# source: google/protobuf/timestamp.proto
+"""Generated protocol buffer code."""
+from lark_channel.ws.pb.google.protobuf.internal import builder as _builder
+from lark_channel.ws.pb.google.protobuf import descriptor as _descriptor
+from lark_channel.ws.pb.google.protobuf import descriptor_pool as _descriptor_pool
+from lark_channel.ws.pb.google.protobuf import symbol_database as _symbol_database
+
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(
+    b'\n\x1fgoogle/protobuf/timestamp.proto\x12\x0fgoogle.protobuf\"+\n\tTimestamp\x12\x0f\n\x07seconds\x18\x01 \x01(\x03\x12\r\n\x05nanos\x18\x02 \x01(\x05\x42\x85\x01\n\x13\x63om.google.protobufB\x0eTimestampProtoP\x01Z2google.golang.org/protobuf/types/known/timestamppb\xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesb\x06proto3')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.timestamp_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+    DESCRIPTOR._options = None
+    DESCRIPTOR._serialized_options = b'\n\023com.google.protobufB\016TimestampProtoP\001Z2google.golang.org/protobuf/types/known/timestamppb\370\001\001\242\002\003GPB\252\002\036Google.Protobuf.WellKnownTypes'
+    _TIMESTAMP._serialized_start = 52
+    _TIMESTAMP._serialized_end = 95
+# @@protoc_insertion_point(module_scope)
diff --git a/lark_channel/ws/pb/google/protobuf/type_pb2.py b/lark_channel/ws/pb/google/protobuf/type_pb2.py
new file mode 100644
index 0000000..7011114
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/type_pb2.py
@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+# source: google/protobuf/type.proto
+"""Generated protocol buffer code."""
+from lark_channel.ws.pb.google.protobuf.internal import builder as _builder
+from lark_channel.ws.pb.google.protobuf import descriptor as _descriptor
+from lark_channel.ws.pb.google.protobuf import descriptor_pool as _descriptor_pool
+from lark_channel.ws.pb.google.protobuf import symbol_database as _symbol_database
+
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+from lark_channel.ws.pb.google.protobuf import any_pb2 as google_dot_protobuf_dot_any__pb2
+from lark_channel.ws.pb.google.protobuf import source_context_pb2 as google_dot_protobuf_dot_source__context__pb2
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(
+    b'\n\x1agoogle/protobuf/type.proto\x12\x0fgoogle.protobuf\x1a\x19google/protobuf/any.proto\x1a$google/protobuf/source_context.proto\"\xd7\x01\n\x04Type\x12\x0c\n\x04name\x18\x01 \x01(\t\x12&\n\x06\x66ields\x18\x02 \x03(\x0b\x32\x16.google.protobuf.Field\x12\x0e\n\x06oneofs\x18\x03 \x03(\t\x12(\n\x07options\x18\x04 \x03(\x0b\x32\x17.google.protobuf.Option\x12\x36\n\x0esource_context\x18\x05 \x01(\x0b\x32\x1e.google.protobuf.SourceContext\x12\'\n\x06syntax\x18\x06 \x01(\x0e\x32\x17.google.protobuf.Syntax\"\xd5\x05\n\x05\x46ield\x12)\n\x04kind\x18\x01 \x01(\x0e\x32\x1b.google.protobuf.Field.Kind\x12\x37\n\x0b\x63\x61rdinality\x18\x02 \x01(\x0e\x32\".google.protobuf.Field.Cardinality\x12\x0e\n\x06number\x18\x03 \x01(\x05\x12\x0c\n\x04name\x18\x04 \x01(\t\x12\x10\n\x08type_url\x18\x06 \x01(\t\x12\x13\n\x0boneof_index\x18\x07 \x01(\x05\x12\x0e\n\x06packed\x18\x08 \x01(\x08\x12(\n\x07options\x18\t \x03(\x0b\x32\x17.google.protobuf.Option\x12\x11\n\tjson_name\x18\n \x01(\t\x12\x15\n\rdefault_value\x18\x0b \x01(\t\"\xc8\x02\n\x04Kind\x12\x10\n\x0cTYPE_UNKNOWN\x10\x00\x12\x0f\n\x0bTYPE_DOUBLE\x10\x01\x12\x0e\n\nTYPE_FLOAT\x10\x02\x12\x0e\n\nTYPE_INT64\x10\x03\x12\x0f\n\x0bTYPE_UINT64\x10\x04\x12\x0e\n\nTYPE_INT32\x10\x05\x12\x10\n\x0cTYPE_FIXED64\x10\x06\x12\x10\n\x0cTYPE_FIXED32\x10\x07\x12\r\n\tTYPE_BOOL\x10\x08\x12\x0f\n\x0bTYPE_STRING\x10\t\x12\x0e\n\nTYPE_GROUP\x10\n\x12\x10\n\x0cTYPE_MESSAGE\x10\x0b\x12\x0e\n\nTYPE_BYTES\x10\x0c\x12\x0f\n\x0bTYPE_UINT32\x10\r\x12\r\n\tTYPE_ENUM\x10\x0e\x12\x11\n\rTYPE_SFIXED32\x10\x0f\x12\x11\n\rTYPE_SFIXED64\x10\x10\x12\x0f\n\x0bTYPE_SINT32\x10\x11\x12\x0f\n\x0bTYPE_SINT64\x10\x12\"t\n\x0b\x43\x61rdinality\x12\x17\n\x13\x43\x41RDINALITY_UNKNOWN\x10\x00\x12\x18\n\x14\x43\x41RDINALITY_OPTIONAL\x10\x01\x12\x18\n\x14\x43\x41RDINALITY_REQUIRED\x10\x02\x12\x18\n\x14\x43\x41RDINALITY_REPEATED\x10\x03\"\xce\x01\n\x04\x45num\x12\x0c\n\x04name\x18\x01 \x01(\t\x12-\n\tenumvalue\x18\x02 \x03(\x0b\x32\x1a.google.protobuf.EnumValue\x12(\n\x07options\x18\x03 \x03(\x0b\x32\x17.google.protobuf.Option\x12\x36\n\x0esource_context\x18\x04 \x01(\x0b\x32\x1e.google.protobuf.SourceContext\x12\'\n\x06syntax\x18\x05 \x01(\x0e\x32\x17.google.protobuf.Syntax\"S\n\tEnumValue\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0e\n\x06number\x18\x02 \x01(\x05\x12(\n\x07options\x18\x03 \x03(\x0b\x32\x17.google.protobuf.Option\";\n\x06Option\x12\x0c\n\x04name\x18\x01 \x01(\t\x12#\n\x05value\x18\x02 \x01(\x0b\x32\x14.google.protobuf.Any*.\n\x06Syntax\x12\x11\n\rSYNTAX_PROTO2\x10\x00\x12\x11\n\rSYNTAX_PROTO3\x10\x01\x42{\n\x13\x63om.google.protobufB\tTypeProtoP\x01Z-google.golang.org/protobuf/types/known/typepb\xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesb\x06proto3')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.type_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+    DESCRIPTOR._options = None
+    DESCRIPTOR._serialized_options = b'\n\023com.google.protobufB\tTypeProtoP\001Z-google.golang.org/protobuf/types/known/typepb\370\001\001\242\002\003GPB\252\002\036Google.Protobuf.WellKnownTypes'
+    _SYNTAX._serialized_start = 1413
+    _SYNTAX._serialized_end = 1459
+    _TYPE._serialized_start = 113
+    _TYPE._serialized_end = 328
+    _FIELD._serialized_start = 331
+    _FIELD._serialized_end = 1056
+    _FIELD_KIND._serialized_start = 610
+    _FIELD_KIND._serialized_end = 938
+    _FIELD_CARDINALITY._serialized_start = 940
+    _FIELD_CARDINALITY._serialized_end = 1056
+    _ENUM._serialized_start = 1059
+    _ENUM._serialized_end = 1265
+    _ENUMVALUE._serialized_start = 1267
+    _ENUMVALUE._serialized_end = 1350
+    _OPTION._serialized_start = 1352
+    _OPTION._serialized_end = 1411
+# @@protoc_insertion_point(module_scope)
diff --git a/lark_channel/ws/pb/google/protobuf/util/__init__.py b/lark_channel/ws/pb/google/protobuf/util/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/lark_channel/ws/pb/google/protobuf/util/json_format_pb2.py b/lark_channel/ws/pb/google/protobuf/util/json_format_pb2.py
new file mode 100644
index 0000000..fe5409a
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/util/json_format_pb2.py
@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+# source: google/protobuf/util/json_format.proto
+"""Generated protocol buffer code."""
+from lark_channel.ws.pb.google.protobuf.internal import builder as _builder
+from lark_channel.ws.pb.google.protobuf import descriptor as _descriptor
+from lark_channel.ws.pb.google.protobuf import descriptor_pool as _descriptor_pool
+from lark_channel.ws.pb.google.protobuf import symbol_database as _symbol_database
+
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(
+    b'\n&google/protobuf/util/json_format.proto\x12\x11protobuf_unittest\"\x89\x01\n\x13TestFlagsAndStrings\x12\t\n\x01\x41\x18\x01 \x02(\x05\x12K\n\rrepeatedgroup\x18\x02 \x03(\n24.protobuf_unittest.TestFlagsAndStrings.RepeatedGroup\x1a\x1a\n\rRepeatedGroup\x12\t\n\x01\x66\x18\x03 \x02(\t\"!\n\x14TestBase64ByteArrays\x12\t\n\x01\x61\x18\x01 \x02(\x0c\"G\n\x12TestJavaScriptJSON\x12\t\n\x01\x61\x18\x01 \x01(\x05\x12\r\n\x05\x66inal\x18\x02 \x01(\x02\x12\n\n\x02in\x18\x03 \x01(\t\x12\x0b\n\x03Var\x18\x04 \x01(\t\"Q\n\x18TestJavaScriptOrderJSON1\x12\t\n\x01\x64\x18\x01 \x01(\x05\x12\t\n\x01\x63\x18\x02 \x01(\x05\x12\t\n\x01x\x18\x03 \x01(\x08\x12\t\n\x01\x62\x18\x04 \x01(\x05\x12\t\n\x01\x61\x18\x05 \x01(\x05\"\x89\x01\n\x18TestJavaScriptOrderJSON2\x12\t\n\x01\x64\x18\x01 \x01(\x05\x12\t\n\x01\x63\x18\x02 \x01(\x05\x12\t\n\x01x\x18\x03 \x01(\x08\x12\t\n\x01\x62\x18\x04 \x01(\x05\x12\t\n\x01\x61\x18\x05 \x01(\x05\x12\x36\n\x01z\x18\x06 \x03(\x0b\x32+.protobuf_unittest.TestJavaScriptOrderJSON1\"$\n\x0cTestLargeInt\x12\t\n\x01\x61\x18\x01 \x02(\x03\x12\t\n\x01\x62\x18\x02 \x02(\x04\"\xa0\x01\n\x0bTestNumbers\x12\x30\n\x01\x61\x18\x01 \x01(\x0e\x32%.protobuf_unittest.TestNumbers.MyType\x12\t\n\x01\x62\x18\x02 \x01(\x05\x12\t\n\x01\x63\x18\x03 \x01(\x02\x12\t\n\x01\x64\x18\x04 \x01(\x08\x12\t\n\x01\x65\x18\x05 \x01(\x01\x12\t\n\x01\x66\x18\x06 \x01(\r\"(\n\x06MyType\x12\x06\n\x02OK\x10\x00\x12\x0b\n\x07WARNING\x10\x01\x12\t\n\x05\x45RROR\x10\x02\"T\n\rTestCamelCase\x12\x14\n\x0cnormal_field\x18\x01 \x01(\t\x12\x15\n\rCAPITAL_FIELD\x18\x02 \x01(\x05\x12\x16\n\x0e\x43\x61melCaseField\x18\x03 \x01(\x05\"|\n\x0bTestBoolMap\x12=\n\x08\x62ool_map\x18\x01 \x03(\x0b\x32+.protobuf_unittest.TestBoolMap.BoolMapEntry\x1a.\n\x0c\x42oolMapEntry\x12\x0b\n\x03key\x18\x01 \x01(\x08\x12\r\n\x05value\x18\x02 \x01(\x05:\x02\x38\x01\"O\n\rTestRecursion\x12\r\n\x05value\x18\x01 \x01(\x05\x12/\n\x05\x63hild\x18\x02 \x01(\x0b\x32 .protobuf_unittest.TestRecursion\"\x86\x01\n\rTestStringMap\x12\x43\n\nstring_map\x18\x01 \x03(\x0b\x32/.protobuf_unittest.TestStringMap.StringMapEntry\x1a\x30\n\x0eStringMapEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"\xc4\x01\n\x14TestStringSerializer\x12\x15\n\rscalar_string\x18\x01 \x01(\t\x12\x17\n\x0frepeated_string\x18\x02 \x03(\t\x12J\n\nstring_map\x18\x03 \x03(\x0b\x32\x36.protobuf_unittest.TestStringSerializer.StringMapEntry\x1a\x30\n\x0eStringMapEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"$\n\x18TestMessageWithExtension*\x08\x08\x64\x10\x80\x80\x80\x80\x02\"z\n\rTestExtension\x12\r\n\x05value\x18\x01 \x01(\t2Z\n\x03\x65xt\x12+.protobuf_unittest.TestMessageWithExtension\x18\x64 \x01(\x0b\x32 .protobuf_unittest.TestExtension\"Q\n\x14TestDefaultEnumValue\x12\x39\n\nenum_value\x18\x01 \x01(\x0e\x32\x1c.protobuf_unittest.EnumValue:\x07\x44\x45\x46\x41ULT*2\n\tEnumValue\x12\x0c\n\x08PROTOCOL\x10\x00\x12\n\n\x06\x42UFFER\x10\x01\x12\x0b\n\x07\x44\x45\x46\x41ULT\x10\x02')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.util.json_format_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+    TestMessageWithExtension.RegisterExtension(_TESTEXTENSION.extensions_by_name['ext'])
+
+    DESCRIPTOR._options = None
+    _TESTBOOLMAP_BOOLMAPENTRY._options = None
+    _TESTBOOLMAP_BOOLMAPENTRY._serialized_options = b'8\001'
+    _TESTSTRINGMAP_STRINGMAPENTRY._options = None
+    _TESTSTRINGMAP_STRINGMAPENTRY._serialized_options = b'8\001'
+    _TESTSTRINGSERIALIZER_STRINGMAPENTRY._options = None
+    _TESTSTRINGSERIALIZER_STRINGMAPENTRY._serialized_options = b'8\001'
+    _ENUMVALUE._serialized_start = 1607
+    _ENUMVALUE._serialized_end = 1657
+    _TESTFLAGSANDSTRINGS._serialized_start = 62
+    _TESTFLAGSANDSTRINGS._serialized_end = 199
+    _TESTFLAGSANDSTRINGS_REPEATEDGROUP._serialized_start = 173
+    _TESTFLAGSANDSTRINGS_REPEATEDGROUP._serialized_end = 199
+    _TESTBASE64BYTEARRAYS._serialized_start = 201
+    _TESTBASE64BYTEARRAYS._serialized_end = 234
+    _TESTJAVASCRIPTJSON._serialized_start = 236
+    _TESTJAVASCRIPTJSON._serialized_end = 307
+    _TESTJAVASCRIPTORDERJSON1._serialized_start = 309
+    _TESTJAVASCRIPTORDERJSON1._serialized_end = 390
+    _TESTJAVASCRIPTORDERJSON2._serialized_start = 393
+    _TESTJAVASCRIPTORDERJSON2._serialized_end = 530
+    _TESTLARGEINT._serialized_start = 532
+    _TESTLARGEINT._serialized_end = 568
+    _TESTNUMBERS._serialized_start = 571
+    _TESTNUMBERS._serialized_end = 731
+    _TESTNUMBERS_MYTYPE._serialized_start = 691
+    _TESTNUMBERS_MYTYPE._serialized_end = 731
+    _TESTCAMELCASE._serialized_start = 733
+    _TESTCAMELCASE._serialized_end = 817
+    _TESTBOOLMAP._serialized_start = 819
+    _TESTBOOLMAP._serialized_end = 943
+    _TESTBOOLMAP_BOOLMAPENTRY._serialized_start = 897
+    _TESTBOOLMAP_BOOLMAPENTRY._serialized_end = 943
+    _TESTRECURSION._serialized_start = 945
+    _TESTRECURSION._serialized_end = 1024
+    _TESTSTRINGMAP._serialized_start = 1027
+    _TESTSTRINGMAP._serialized_end = 1161
+    _TESTSTRINGMAP_STRINGMAPENTRY._serialized_start = 1113
+    _TESTSTRINGMAP_STRINGMAPENTRY._serialized_end = 1161
+    _TESTSTRINGSERIALIZER._serialized_start = 1164
+    _TESTSTRINGSERIALIZER._serialized_end = 1360
+    _TESTSTRINGSERIALIZER_STRINGMAPENTRY._serialized_start = 1113
+    _TESTSTRINGSERIALIZER_STRINGMAPENTRY._serialized_end = 1161
+    _TESTMESSAGEWITHEXTENSION._serialized_start = 1362
+    _TESTMESSAGEWITHEXTENSION._serialized_end = 1398
+    _TESTEXTENSION._serialized_start = 1400
+    _TESTEXTENSION._serialized_end = 1522
+    _TESTDEFAULTENUMVALUE._serialized_start = 1524
+    _TESTDEFAULTENUMVALUE._serialized_end = 1605
+# @@protoc_insertion_point(module_scope)
diff --git a/lark_channel/ws/pb/google/protobuf/util/json_format_proto3_pb2.py b/lark_channel/ws/pb/google/protobuf/util/json_format_proto3_pb2.py
new file mode 100644
index 0000000..2c4cf44
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/util/json_format_proto3_pb2.py
@@ -0,0 +1,127 @@
+# -*- coding: utf-8 -*-
+# source: google/protobuf/util/json_format_proto3.proto
+"""Generated protocol buffer code."""
+from lark_channel.ws.pb.google.protobuf.internal import builder as _builder
+from lark_channel.ws.pb.google.protobuf import descriptor as _descriptor
+from lark_channel.ws.pb.google.protobuf import descriptor_pool as _descriptor_pool
+from lark_channel.ws.pb.google.protobuf import symbol_database as _symbol_database
+
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+from lark_channel.ws.pb.google.protobuf import any_pb2 as google_dot_protobuf_dot_any__pb2
+from lark_channel.ws.pb.google.protobuf import duration_pb2 as google_dot_protobuf_dot_duration__pb2
+from lark_channel.ws.pb.google.protobuf import field_mask_pb2 as google_dot_protobuf_dot_field__mask__pb2
+from lark_channel.ws.pb.google.protobuf import struct_pb2 as google_dot_protobuf_dot_struct__pb2
+from lark_channel.ws.pb.google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2
+from lark_channel.ws.pb.google.protobuf import wrappers_pb2 as google_dot_protobuf_dot_wrappers__pb2
+from lark_channel.ws.pb.google.protobuf import unittest_pb2 as google_dot_protobuf_dot_unittest__pb2
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(
+    b'\n-google/protobuf/util/json_format_proto3.proto\x12\x06proto3\x1a\x19google/protobuf/any.proto\x1a\x1egoogle/protobuf/duration.proto\x1a google/protobuf/field_mask.proto\x1a\x1cgoogle/protobuf/struct.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x1egoogle/protobuf/wrappers.proto\x1a\x1egoogle/protobuf/unittest.proto\"\x1c\n\x0bMessageType\x12\r\n\x05value\x18\x01 \x01(\x05\"\x94\x05\n\x0bTestMessage\x12\x12\n\nbool_value\x18\x01 \x01(\x08\x12\x13\n\x0bint32_value\x18\x02 \x01(\x05\x12\x13\n\x0bint64_value\x18\x03 \x01(\x03\x12\x14\n\x0cuint32_value\x18\x04 \x01(\r\x12\x14\n\x0cuint64_value\x18\x05 \x01(\x04\x12\x13\n\x0b\x66loat_value\x18\x06 \x01(\x02\x12\x14\n\x0c\x64ouble_value\x18\x07 \x01(\x01\x12\x14\n\x0cstring_value\x18\x08 \x01(\t\x12\x13\n\x0b\x62ytes_value\x18\t \x01(\x0c\x12$\n\nenum_value\x18\n \x01(\x0e\x32\x10.proto3.EnumType\x12*\n\rmessage_value\x18\x0b \x01(\x0b\x32\x13.proto3.MessageType\x12\x1b\n\x13repeated_bool_value\x18\x15 \x03(\x08\x12\x1c\n\x14repeated_int32_value\x18\x16 \x03(\x05\x12\x1c\n\x14repeated_int64_value\x18\x17 \x03(\x03\x12\x1d\n\x15repeated_uint32_value\x18\x18 \x03(\r\x12\x1d\n\x15repeated_uint64_value\x18\x19 \x03(\x04\x12\x1c\n\x14repeated_float_value\x18\x1a \x03(\x02\x12\x1d\n\x15repeated_double_value\x18\x1b \x03(\x01\x12\x1d\n\x15repeated_string_value\x18\x1c \x03(\t\x12\x1c\n\x14repeated_bytes_value\x18\x1d \x03(\x0c\x12-\n\x13repeated_enum_value\x18\x1e \x03(\x0e\x32\x10.proto3.EnumType\x12\x33\n\x16repeated_message_value\x18\x1f \x03(\x0b\x32\x13.proto3.MessageType\"\x8c\x02\n\tTestOneof\x12\x1b\n\x11oneof_int32_value\x18\x01 \x01(\x05H\x00\x12\x1c\n\x12oneof_string_value\x18\x02 \x01(\tH\x00\x12\x1b\n\x11oneof_bytes_value\x18\x03 \x01(\x0cH\x00\x12,\n\x10oneof_enum_value\x18\x04 \x01(\x0e\x32\x10.proto3.EnumTypeH\x00\x12\x32\n\x13oneof_message_value\x18\x05 \x01(\x0b\x32\x13.proto3.MessageTypeH\x00\x12\x36\n\x10oneof_null_value\x18\x06 \x01(\x0e\x32\x1a.google.protobuf.NullValueH\x00\x42\r\n\x0boneof_value\"\xe1\x04\n\x07TestMap\x12.\n\x08\x62ool_map\x18\x01 \x03(\x0b\x32\x1c.proto3.TestMap.BoolMapEntry\x12\x30\n\tint32_map\x18\x02 \x03(\x0b\x32\x1d.proto3.TestMap.Int32MapEntry\x12\x30\n\tint64_map\x18\x03 \x03(\x0b\x32\x1d.proto3.TestMap.Int64MapEntry\x12\x32\n\nuint32_map\x18\x04 \x03(\x0b\x32\x1e.proto3.TestMap.Uint32MapEntry\x12\x32\n\nuint64_map\x18\x05 \x03(\x0b\x32\x1e.proto3.TestMap.Uint64MapEntry\x12\x32\n\nstring_map\x18\x06 \x03(\x0b\x32\x1e.proto3.TestMap.StringMapEntry\x1a.\n\x0c\x42oolMapEntry\x12\x0b\n\x03key\x18\x01 \x01(\x08\x12\r\n\x05value\x18\x02 \x01(\x05:\x02\x38\x01\x1a/\n\rInt32MapEntry\x12\x0b\n\x03key\x18\x01 \x01(\x05\x12\r\n\x05value\x18\x02 \x01(\x05:\x02\x38\x01\x1a/\n\rInt64MapEntry\x12\x0b\n\x03key\x18\x01 \x01(\x03\x12\r\n\x05value\x18\x02 \x01(\x05:\x02\x38\x01\x1a\x30\n\x0eUint32MapEntry\x12\x0b\n\x03key\x18\x01 \x01(\r\x12\r\n\x05value\x18\x02 \x01(\x05:\x02\x38\x01\x1a\x30\n\x0eUint64MapEntry\x12\x0b\n\x03key\x18\x01 \x01(\x04\x12\r\n\x05value\x18\x02 \x01(\x05:\x02\x38\x01\x1a\x30\n\x0eStringMapEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x05:\x02\x38\x01\"\x85\x06\n\rTestNestedMap\x12\x34\n\x08\x62ool_map\x18\x01 \x03(\x0b\x32\".proto3.TestNestedMap.BoolMapEntry\x12\x36\n\tint32_map\x18\x02 \x03(\x0b\x32#.proto3.TestNestedMap.Int32MapEntry\x12\x36\n\tint64_map\x18\x03 \x03(\x0b\x32#.proto3.TestNestedMap.Int64MapEntry\x12\x38\n\nuint32_map\x18\x04 \x03(\x0b\x32$.proto3.TestNestedMap.Uint32MapEntry\x12\x38\n\nuint64_map\x18\x05 \x03(\x0b\x32$.proto3.TestNestedMap.Uint64MapEntry\x12\x38\n\nstring_map\x18\x06 \x03(\x0b\x32$.proto3.TestNestedMap.StringMapEntry\x12\x32\n\x07map_map\x18\x07 \x03(\x0b\x32!.proto3.TestNestedMap.MapMapEntry\x1a.\n\x0c\x42oolMapEntry\x12\x0b\n\x03key\x18\x01 \x01(\x08\x12\r\n\x05value\x18\x02 \x01(\x05:\x02\x38\x01\x1a/\n\rInt32MapEntry\x12\x0b\n\x03key\x18\x01 \x01(\x05\x12\r\n\x05value\x18\x02 \x01(\x05:\x02\x38\x01\x1a/\n\rInt64MapEntry\x12\x0b\n\x03key\x18\x01 \x01(\x03\x12\r\n\x05value\x18\x02 \x01(\x05:\x02\x38\x01\x1a\x30\n\x0eUint32MapEntry\x12\x0b\n\x03key\x18\x01 \x01(\r\x12\r\n\x05value\x18\x02 \x01(\x05:\x02\x38\x01\x1a\x30\n\x0eUint64MapEntry\x12\x0b\n\x03key\x18\x01 \x01(\x04\x12\r\n\x05value\x18\x02 \x01(\x05:\x02\x38\x01\x1a\x30\n\x0eStringMapEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x05:\x02\x38\x01\x1a\x44\n\x0bMapMapEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12$\n\x05value\x18\x02 \x01(\x0b\x32\x15.proto3.TestNestedMap:\x02\x38\x01\"{\n\rTestStringMap\x12\x38\n\nstring_map\x18\x01 \x03(\x0b\x32$.proto3.TestStringMap.StringMapEntry\x1a\x30\n\x0eStringMapEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"\xee\x07\n\x0bTestWrapper\x12.\n\nbool_value\x18\x01 \x01(\x0b\x32\x1a.google.protobuf.BoolValue\x12\x30\n\x0bint32_value\x18\x02 \x01(\x0b\x32\x1b.google.protobuf.Int32Value\x12\x30\n\x0bint64_value\x18\x03 \x01(\x0b\x32\x1b.google.protobuf.Int64Value\x12\x32\n\x0cuint32_value\x18\x04 \x01(\x0b\x32\x1c.google.protobuf.UInt32Value\x12\x32\n\x0cuint64_value\x18\x05 \x01(\x0b\x32\x1c.google.protobuf.UInt64Value\x12\x30\n\x0b\x66loat_value\x18\x06 \x01(\x0b\x32\x1b.google.protobuf.FloatValue\x12\x32\n\x0c\x64ouble_value\x18\x07 \x01(\x0b\x32\x1c.google.protobuf.DoubleValue\x12\x32\n\x0cstring_value\x18\x08 \x01(\x0b\x32\x1c.google.protobuf.StringValue\x12\x30\n\x0b\x62ytes_value\x18\t \x01(\x0b\x32\x1b.google.protobuf.BytesValue\x12\x37\n\x13repeated_bool_value\x18\x0b \x03(\x0b\x32\x1a.google.protobuf.BoolValue\x12\x39\n\x14repeated_int32_value\x18\x0c \x03(\x0b\x32\x1b.google.protobuf.Int32Value\x12\x39\n\x14repeated_int64_value\x18\r \x03(\x0b\x32\x1b.google.protobuf.Int64Value\x12;\n\x15repeated_uint32_value\x18\x0e \x03(\x0b\x32\x1c.google.protobuf.UInt32Value\x12;\n\x15repeated_uint64_value\x18\x0f \x03(\x0b\x32\x1c.google.protobuf.UInt64Value\x12\x39\n\x14repeated_float_value\x18\x10 \x03(\x0b\x32\x1b.google.protobuf.FloatValue\x12;\n\x15repeated_double_value\x18\x11 \x03(\x0b\x32\x1c.google.protobuf.DoubleValue\x12;\n\x15repeated_string_value\x18\x12 \x03(\x0b\x32\x1c.google.protobuf.StringValue\x12\x39\n\x14repeated_bytes_value\x18\x13 \x03(\x0b\x32\x1b.google.protobuf.BytesValue\"n\n\rTestTimestamp\x12)\n\x05value\x18\x01 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x32\n\x0erepeated_value\x18\x02 \x03(\x0b\x32\x1a.google.protobuf.Timestamp\"k\n\x0cTestDuration\x12(\n\x05value\x18\x01 \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x31\n\x0erepeated_value\x18\x02 \x03(\x0b\x32\x19.google.protobuf.Duration\":\n\rTestFieldMask\x12)\n\x05value\x18\x01 \x01(\x0b\x32\x1a.google.protobuf.FieldMask\"e\n\nTestStruct\x12&\n\x05value\x18\x01 \x01(\x0b\x32\x17.google.protobuf.Struct\x12/\n\x0erepeated_value\x18\x02 \x03(\x0b\x32\x17.google.protobuf.Struct\"\\\n\x07TestAny\x12#\n\x05value\x18\x01 \x01(\x0b\x32\x14.google.protobuf.Any\x12,\n\x0erepeated_value\x18\x02 \x03(\x0b\x32\x14.google.protobuf.Any\"b\n\tTestValue\x12%\n\x05value\x18\x01 \x01(\x0b\x32\x16.google.protobuf.Value\x12.\n\x0erepeated_value\x18\x02 \x03(\x0b\x32\x16.google.protobuf.Value\"n\n\rTestListValue\x12)\n\x05value\x18\x01 \x01(\x0b\x32\x1a.google.protobuf.ListValue\x12\x32\n\x0erepeated_value\x18\x02 \x03(\x0b\x32\x1a.google.protobuf.ListValue\"\x89\x01\n\rTestBoolValue\x12\x12\n\nbool_value\x18\x01 \x01(\x08\x12\x34\n\x08\x62ool_map\x18\x02 \x03(\x0b\x32\".proto3.TestBoolValue.BoolMapEntry\x1a.\n\x0c\x42oolMapEntry\x12\x0b\n\x03key\x18\x01 \x01(\x08\x12\r\n\x05value\x18\x02 \x01(\x05:\x02\x38\x01\"+\n\x12TestCustomJsonName\x12\x15\n\x05value\x18\x01 \x01(\x05R\x06@value\"J\n\x0eTestExtensions\x12\x38\n\nextensions\x18\x01 \x01(\x0b\x32$.protobuf_unittest.TestAllExtensions\"\x84\x01\n\rTestEnumValue\x12%\n\x0b\x65num_value1\x18\x01 \x01(\x0e\x32\x10.proto3.EnumType\x12%\n\x0b\x65num_value2\x18\x02 \x01(\x0e\x32\x10.proto3.EnumType\x12%\n\x0b\x65num_value3\x18\x03 \x01(\x0e\x32\x10.proto3.EnumType*\x1c\n\x08\x45numType\x12\x07\n\x03\x46OO\x10\x00\x12\x07\n\x03\x42\x41R\x10\x01\x42,\n\x18\x63om.google.protobuf.utilB\x10JsonFormatProto3b\x06proto3')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.util.json_format_proto3_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+    DESCRIPTOR._options = None
+    DESCRIPTOR._serialized_options = b'\n\030com.google.protobuf.utilB\020JsonFormatProto3'
+    _TESTMAP_BOOLMAPENTRY._options = None
+    _TESTMAP_BOOLMAPENTRY._serialized_options = b'8\001'
+    _TESTMAP_INT32MAPENTRY._options = None
+    _TESTMAP_INT32MAPENTRY._serialized_options = b'8\001'
+    _TESTMAP_INT64MAPENTRY._options = None
+    _TESTMAP_INT64MAPENTRY._serialized_options = b'8\001'
+    _TESTMAP_UINT32MAPENTRY._options = None
+    _TESTMAP_UINT32MAPENTRY._serialized_options = b'8\001'
+    _TESTMAP_UINT64MAPENTRY._options = None
+    _TESTMAP_UINT64MAPENTRY._serialized_options = b'8\001'
+    _TESTMAP_STRINGMAPENTRY._options = None
+    _TESTMAP_STRINGMAPENTRY._serialized_options = b'8\001'
+    _TESTNESTEDMAP_BOOLMAPENTRY._options = None
+    _TESTNESTEDMAP_BOOLMAPENTRY._serialized_options = b'8\001'
+    _TESTNESTEDMAP_INT32MAPENTRY._options = None
+    _TESTNESTEDMAP_INT32MAPENTRY._serialized_options = b'8\001'
+    _TESTNESTEDMAP_INT64MAPENTRY._options = None
+    _TESTNESTEDMAP_INT64MAPENTRY._serialized_options = b'8\001'
+    _TESTNESTEDMAP_UINT32MAPENTRY._options = None
+    _TESTNESTEDMAP_UINT32MAPENTRY._serialized_options = b'8\001'
+    _TESTNESTEDMAP_UINT64MAPENTRY._options = None
+    _TESTNESTEDMAP_UINT64MAPENTRY._serialized_options = b'8\001'
+    _TESTNESTEDMAP_STRINGMAPENTRY._options = None
+    _TESTNESTEDMAP_STRINGMAPENTRY._serialized_options = b'8\001'
+    _TESTNESTEDMAP_MAPMAPENTRY._options = None
+    _TESTNESTEDMAP_MAPMAPENTRY._serialized_options = b'8\001'
+    _TESTSTRINGMAP_STRINGMAPENTRY._options = None
+    _TESTSTRINGMAP_STRINGMAPENTRY._serialized_options = b'8\001'
+    _TESTBOOLVALUE_BOOLMAPENTRY._options = None
+    _TESTBOOLVALUE_BOOLMAPENTRY._serialized_options = b'8\001'
+    _ENUMTYPE._serialized_start = 4849
+    _ENUMTYPE._serialized_end = 4877
+    _MESSAGETYPE._serialized_start = 277
+    _MESSAGETYPE._serialized_end = 305
+    _TESTMESSAGE._serialized_start = 308
+    _TESTMESSAGE._serialized_end = 968
+    _TESTONEOF._serialized_start = 971
+    _TESTONEOF._serialized_end = 1239
+    _TESTMAP._serialized_start = 1242
+    _TESTMAP._serialized_end = 1851
+    _TESTMAP_BOOLMAPENTRY._serialized_start = 1557
+    _TESTMAP_BOOLMAPENTRY._serialized_end = 1603
+    _TESTMAP_INT32MAPENTRY._serialized_start = 1605
+    _TESTMAP_INT32MAPENTRY._serialized_end = 1652
+    _TESTMAP_INT64MAPENTRY._serialized_start = 1654
+    _TESTMAP_INT64MAPENTRY._serialized_end = 1701
+    _TESTMAP_UINT32MAPENTRY._serialized_start = 1703
+    _TESTMAP_UINT32MAPENTRY._serialized_end = 1751
+    _TESTMAP_UINT64MAPENTRY._serialized_start = 1753
+    _TESTMAP_UINT64MAPENTRY._serialized_end = 1801
+    _TESTMAP_STRINGMAPENTRY._serialized_start = 1803
+    _TESTMAP_STRINGMAPENTRY._serialized_end = 1851
+    _TESTNESTEDMAP._serialized_start = 1854
+    _TESTNESTEDMAP._serialized_end = 2627
+    _TESTNESTEDMAP_BOOLMAPENTRY._serialized_start = 1557
+    _TESTNESTEDMAP_BOOLMAPENTRY._serialized_end = 1603
+    _TESTNESTEDMAP_INT32MAPENTRY._serialized_start = 1605
+    _TESTNESTEDMAP_INT32MAPENTRY._serialized_end = 1652
+    _TESTNESTEDMAP_INT64MAPENTRY._serialized_start = 1654
+    _TESTNESTEDMAP_INT64MAPENTRY._serialized_end = 1701
+    _TESTNESTEDMAP_UINT32MAPENTRY._serialized_start = 1703
+    _TESTNESTEDMAP_UINT32MAPENTRY._serialized_end = 1751
+    _TESTNESTEDMAP_UINT64MAPENTRY._serialized_start = 1753
+    _TESTNESTEDMAP_UINT64MAPENTRY._serialized_end = 1801
+    _TESTNESTEDMAP_STRINGMAPENTRY._serialized_start = 1803
+    _TESTNESTEDMAP_STRINGMAPENTRY._serialized_end = 1851
+    _TESTNESTEDMAP_MAPMAPENTRY._serialized_start = 2559
+    _TESTNESTEDMAP_MAPMAPENTRY._serialized_end = 2627
+    _TESTSTRINGMAP._serialized_start = 2629
+    _TESTSTRINGMAP._serialized_end = 2752
+    _TESTSTRINGMAP_STRINGMAPENTRY._serialized_start = 2704
+    _TESTSTRINGMAP_STRINGMAPENTRY._serialized_end = 2752
+    _TESTWRAPPER._serialized_start = 2755
+    _TESTWRAPPER._serialized_end = 3761
+    _TESTTIMESTAMP._serialized_start = 3763
+    _TESTTIMESTAMP._serialized_end = 3873
+    _TESTDURATION._serialized_start = 3875
+    _TESTDURATION._serialized_end = 3982
+    _TESTFIELDMASK._serialized_start = 3984
+    _TESTFIELDMASK._serialized_end = 4042
+    _TESTSTRUCT._serialized_start = 4044
+    _TESTSTRUCT._serialized_end = 4145
+    _TESTANY._serialized_start = 4147
+    _TESTANY._serialized_end = 4239
+    _TESTVALUE._serialized_start = 4241
+    _TESTVALUE._serialized_end = 4339
+    _TESTLISTVALUE._serialized_start = 4341
+    _TESTLISTVALUE._serialized_end = 4451
+    _TESTBOOLVALUE._serialized_start = 4454
+    _TESTBOOLVALUE._serialized_end = 4591
+    _TESTBOOLVALUE_BOOLMAPENTRY._serialized_start = 1557
+    _TESTBOOLVALUE_BOOLMAPENTRY._serialized_end = 1603
+    _TESTCUSTOMJSONNAME._serialized_start = 4593
+    _TESTCUSTOMJSONNAME._serialized_end = 4636
+    _TESTEXTENSIONS._serialized_start = 4638
+    _TESTEXTENSIONS._serialized_end = 4712
+    _TESTENUMVALUE._serialized_start = 4715
+    _TESTENUMVALUE._serialized_end = 4847
+# @@protoc_insertion_point(module_scope)
diff --git a/lark_channel/ws/pb/google/protobuf/wrappers_pb2.py b/lark_channel/ws/pb/google/protobuf/wrappers_pb2.py
new file mode 100644
index 0000000..8ac900c
--- /dev/null
+++ b/lark_channel/ws/pb/google/protobuf/wrappers_pb2.py
@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+# source: google/protobuf/wrappers.proto
+"""Generated protocol buffer code."""
+from lark_channel.ws.pb.google.protobuf.internal import builder as _builder
+from lark_channel.ws.pb.google.protobuf import descriptor as _descriptor
+from lark_channel.ws.pb.google.protobuf import descriptor_pool as _descriptor_pool
+from lark_channel.ws.pb.google.protobuf import symbol_database as _symbol_database
+
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(
+    b'\n\x1egoogle/protobuf/wrappers.proto\x12\x0fgoogle.protobuf\"\x1c\n\x0b\x44oubleValue\x12\r\n\x05value\x18\x01 \x01(\x01\"\x1b\n\nFloatValue\x12\r\n\x05value\x18\x01 \x01(\x02\"\x1b\n\nInt64Value\x12\r\n\x05value\x18\x01 \x01(\x03\"\x1c\n\x0bUInt64Value\x12\r\n\x05value\x18\x01 \x01(\x04\"\x1b\n\nInt32Value\x12\r\n\x05value\x18\x01 \x01(\x05\"\x1c\n\x0bUInt32Value\x12\r\n\x05value\x18\x01 \x01(\r\"\x1a\n\tBoolValue\x12\r\n\x05value\x18\x01 \x01(\x08\"\x1c\n\x0bStringValue\x12\r\n\x05value\x18\x01 \x01(\t\"\x1b\n\nBytesValue\x12\r\n\x05value\x18\x01 \x01(\x0c\x42\x83\x01\n\x13\x63om.google.protobufB\rWrappersProtoP\x01Z1google.golang.org/protobuf/types/known/wrapperspb\xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesb\x06proto3')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.wrappers_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+    DESCRIPTOR._options = None
+    DESCRIPTOR._serialized_options = b'\n\023com.google.protobufB\rWrappersProtoP\001Z1google.golang.org/protobuf/types/known/wrapperspb\370\001\001\242\002\003GPB\252\002\036Google.Protobuf.WellKnownTypes'
+    _DOUBLEVALUE._serialized_start = 51
+    _DOUBLEVALUE._serialized_end = 79
+    _FLOATVALUE._serialized_start = 81
+    _FLOATVALUE._serialized_end = 108
+    _INT64VALUE._serialized_start = 110
+    _INT64VALUE._serialized_end = 137
+    _UINT64VALUE._serialized_start = 139
+    _UINT64VALUE._serialized_end = 167
+    _INT32VALUE._serialized_start = 169
+    _INT32VALUE._serialized_end = 196
+    _UINT32VALUE._serialized_start = 198
+    _UINT32VALUE._serialized_end = 226
+    _BOOLVALUE._serialized_start = 228
+    _BOOLVALUE._serialized_end = 254
+    _STRINGVALUE._serialized_start = 256
+    _STRINGVALUE._serialized_end = 284
+    _BYTESVALUE._serialized_start = 286
+    _BYTESVALUE._serialized_end = 313
+# @@protoc_insertion_point(module_scope)
diff --git a/lark_channel/ws/pb/pbbp2_pb2.py b/lark_channel/ws/pb/pbbp2_pb2.py
new file mode 100644
index 0000000..dc76ccb
--- /dev/null
+++ b/lark_channel/ws/pb/pbbp2_pb2.py
@@ -0,0 +1,170 @@
+# -*- coding: utf-8 -*-
+# source: pbbp2.proto
+
+from lark_channel.ws.pb.google.protobuf import descriptor as _descriptor
+from lark_channel.ws.pb.google.protobuf import message as _message
+from lark_channel.ws.pb.google.protobuf import reflection as _reflection
+from lark_channel.ws.pb.google.protobuf import symbol_database as _symbol_database
+
+from . import gogo_pb2
+
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+    name='pbbp2.proto',
+    package='pbbp2',
+    syntax='proto2',
+    serialized_options=None,
+    create_key=_descriptor._internal_create_key,
+    serialized_pb=b'\n\x0bpbbp2.proto\x12\x05pbbp2\x1a\ngogo.proto\"$\n\x06Header\x12\x0b\n\x03key\x18\x01 \x02(\t\x12\r\n\x05value\x18\x02 \x02(\t\"\xbf\x01\n\x05\x46rame\x12\r\n\x05SeqID\x18\x01 \x02(\x04\x12\r\n\x05LogID\x18\x02 \x02(\x04\x12\x0f\n\x07service\x18\x03 \x02(\x05\x12\x0e\n\x06method\x18\x04 \x02(\x05\x12$\n\x07headers\x18\x05 \x03(\x0b\x32\r.pbbp2.HeaderB\x04\xc8\xde\x1f\x00\x12\x18\n\x10payload_encoding\x18\x06 \x01(\t\x12\x14\n\x0cpayload_type\x18\x07 \x01(\t\x12\x0f\n\x07payload\x18\x08 \x01(\x0c\x12\x10\n\x08LogIDNew\x18\t \x01(\t'
+    ,
+    dependencies=[gogo_pb2.DESCRIPTOR, ])
+
+_HEADER = _descriptor.Descriptor(
+    name='Header',
+    full_name='pbbp2.Header',
+    filename=None,
+    file=DESCRIPTOR,
+    containing_type=None,
+    create_key=_descriptor._internal_create_key,
+    fields=[
+        _descriptor.FieldDescriptor(
+            name='key', full_name='pbbp2.Header.key', index=0,
+            number=1, type=9, cpp_type=9, label=2,
+            has_default_value=False, default_value=b"".decode('utf-8'),
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        _descriptor.FieldDescriptor(
+            name='value', full_name='pbbp2.Header.value', index=1,
+            number=2, type=9, cpp_type=9, label=2,
+            has_default_value=False, default_value=b"".decode('utf-8'),
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+    ],
+    extensions=[
+    ],
+    nested_types=[],
+    enum_types=[
+    ],
+    serialized_options=None,
+    is_extendable=False,
+    syntax='proto2',
+    extension_ranges=[],
+    oneofs=[
+    ],
+    serialized_start=34,
+    serialized_end=70,
+)
+
+_FRAME = _descriptor.Descriptor(
+    name='Frame',
+    full_name='pbbp2.Frame',
+    filename=None,
+    file=DESCRIPTOR,
+    containing_type=None,
+    create_key=_descriptor._internal_create_key,
+    fields=[
+        _descriptor.FieldDescriptor(
+            name='SeqID', full_name='pbbp2.Frame.SeqID', index=0,
+            number=1, type=4, cpp_type=4, label=2,
+            has_default_value=False, default_value=0,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        _descriptor.FieldDescriptor(
+            name='LogID', full_name='pbbp2.Frame.LogID', index=1,
+            number=2, type=4, cpp_type=4, label=2,
+            has_default_value=False, default_value=0,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        _descriptor.FieldDescriptor(
+            name='service', full_name='pbbp2.Frame.service', index=2,
+            number=3, type=5, cpp_type=1, label=2,
+            has_default_value=False, default_value=0,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        _descriptor.FieldDescriptor(
+            name='method', full_name='pbbp2.Frame.method', index=3,
+            number=4, type=5, cpp_type=1, label=2,
+            has_default_value=False, default_value=0,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        _descriptor.FieldDescriptor(
+            name='headers', full_name='pbbp2.Frame.headers', index=4,
+            number=5, type=11, cpp_type=10, label=3,
+            has_default_value=False, default_value=[],
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            serialized_options=b'\310\336\037\000', file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        _descriptor.FieldDescriptor(
+            name='payload_encoding', full_name='pbbp2.Frame.payload_encoding', index=5,
+            number=6, type=9, cpp_type=9, label=1,
+            has_default_value=False, default_value=b"".decode('utf-8'),
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        _descriptor.FieldDescriptor(
+            name='payload_type', full_name='pbbp2.Frame.payload_type', index=6,
+            number=7, type=9, cpp_type=9, label=1,
+            has_default_value=False, default_value=b"".decode('utf-8'),
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        _descriptor.FieldDescriptor(
+            name='payload', full_name='pbbp2.Frame.payload', index=7,
+            number=8, type=12, cpp_type=9, label=1,
+            has_default_value=False, default_value=b"",
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+        _descriptor.FieldDescriptor(
+            name='LogIDNew', full_name='pbbp2.Frame.LogIDNew', index=8,
+            number=9, type=9, cpp_type=9, label=1,
+            has_default_value=False, default_value=b"".decode('utf-8'),
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
+    ],
+    extensions=[
+    ],
+    nested_types=[],
+    enum_types=[
+    ],
+    serialized_options=None,
+    is_extendable=False,
+    syntax='proto2',
+    extension_ranges=[],
+    oneofs=[
+    ],
+    serialized_start=73,
+    serialized_end=264,
+)
+
+_FRAME.fields_by_name['headers'].message_type = _HEADER
+DESCRIPTOR.message_types_by_name['Header'] = _HEADER
+DESCRIPTOR.message_types_by_name['Frame'] = _FRAME
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+Header = _reflection.GeneratedProtocolMessageType('Header', (_message.Message,), {
+    'DESCRIPTOR': _HEADER,
+    '__module__': 'pbbp2_pb2'
+    # @@protoc_insertion_point(class_scope:pbbp2.Header)
+})
+_sym_db.RegisterMessage(Header)
+
+Frame = _reflection.GeneratedProtocolMessageType('Frame', (_message.Message,), {
+    'DESCRIPTOR': _FRAME,
+    '__module__': 'pbbp2_pb2'
+    # @@protoc_insertion_point(class_scope:pbbp2.Frame)
+})
+_sym_db.RegisterMessage(Frame)
+
+_FRAME.fields_by_name['headers']._options = None
+# @@protoc_insertion_point(module_scope)
diff --git a/lark_channel/ws/tests/__init__.py b/lark_channel/ws/tests/__init__.py
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/lark_channel/ws/tests/__init__.py
@@ -0,0 +1 @@
+
diff --git a/lark_channel/ws/tests/test_websockets_compat.py b/lark_channel/ws/tests/test_websockets_compat.py
new file mode 100644
index 0000000..a179853
--- /dev/null
+++ b/lark_channel/ws/tests/test_websockets_compat.py
@@ -0,0 +1,142 @@
+from types import SimpleNamespace
+
+import pytest
+
+from lark_channel.ws import client as ws_client
+from lark_channel.ws.const import (
+    EXCEED_CONN_LIMIT,
+    HEADER_HANDSHAKE_AUTH_ERRCODE,
+    HEADER_HANDSHAKE_MSG,
+    HEADER_HANDSHAKE_STATUS,
+)
+from lark_channel.ws.exception import ClientException
+
+
+class _FakeConn:
+    async def close(self):
+        pass
+
+
+def test_parse_ws_connection_exception_reads_new_invalid_status_response_headers():
+    exc = RuntimeError("handshake failed")
+    exc.response = SimpleNamespace(
+        headers={
+            HEADER_HANDSHAKE_STATUS: "514",
+            HEADER_HANDSHAKE_MSG: "too many connections",
+            HEADER_HANDSHAKE_AUTH_ERRCODE: str(EXCEED_CONN_LIMIT),
+        }
+    )
+
+    with pytest.raises(ClientException) as err:
+        ws_client._parse_ws_conn_exception(exc)
+
+    assert err.value.code == 514
+    assert str(err.value) == "514: too many connections"
+
+
+def test_parse_ws_connection_exception_keeps_legacy_headers_behavior():
+    exc = RuntimeError("handshake failed")
+    exc.headers = {
+        HEADER_HANDSHAKE_STATUS: "514",
+        HEADER_HANDSHAKE_MSG: "too many connections",
+        HEADER_HANDSHAKE_AUTH_ERRCODE: str(EXCEED_CONN_LIMIT),
+    }
+
+    with pytest.raises(ClientException) as err:
+        ws_client._parse_ws_conn_exception(exc)
+
+    assert err.value.code == 514
+    assert str(err.value) == "514: too many connections"
+
+
+def test_get_conn_url_sends_custom_headers(monkeypatch):
+    captured = {}
+
+    def fake_post(url, *, headers=None, json=None):
+        captured["url"] = url
+        captured["headers"] = headers
+        captured["json"] = json
+        return SimpleNamespace(
+            status_code=200,
+            content=b'{"code":0,"data":{"URL":"ws://example.test/callback?device_id=device&service_id=42"}}',
+        )
+
+    client = ws_client.Client(
+        "app_id",
+        "app_secret",
+        headers={
+            "x-custom-header": "custom-value",
+            "x-extra-header": "1",
+            "locale": "en",
+            ws_client.USER_AGENT: "custom-agent",
+        },
+    )
+    monkeypatch.setattr(ws_client.requests, "post", fake_post)
+
+    assert client._get_conn_url() == "ws://example.test/callback?device_id=device&service_id=42"
+    assert captured["url"] == client._domain + ws_client.GEN_ENDPOINT_URI
+    assert captured["json"] == {"AppID": "app_id", "AppSecret": "app_secret"}
+    assert captured["headers"]["x-custom-header"] == "custom-value"
+    assert captured["headers"]["x-extra-header"] == "1"
+    assert captured["headers"]["locale"] == "zh"
+    assert captured["headers"][ws_client.USER_AGENT] == client._user_agent
+
+
+@pytest.mark.asyncio
+async def test_connect_disables_websockets_15_automatic_proxy(monkeypatch):
+    captured = {}
+
+    async def fake_connect(uri, *, proxy=True):
+        captured["uri"] = uri
+        captured["proxy"] = proxy
+        return _FakeConn()
+
+    client = ws_client.Client("app_id", "app_secret")
+    monkeypatch.setattr(
+        client,
+        "_get_conn_url",
+        lambda: "ws://example.test/callback?device_id=device&service_id=42",
+    )
+    monkeypatch.setattr(ws_client.websockets, "connect", fake_connect)
+    monkeypatch.setattr(
+        ws_client.loop,
+        "create_task",
+        lambda coro: coro.close() if hasattr(coro, "close") else None,
+    )
+
+    await client._connect()
+    await client._disconnect()
+
+    assert captured == {
+        "uri": "ws://example.test/callback?device_id=device&service_id=42",
+        "proxy": None,
+    }
+
+
+@pytest.mark.asyncio
+async def test_connect_does_not_pass_proxy_to_older_websockets(monkeypatch):
+    captured = {}
+
+    async def fake_connect(uri):
+        captured["uri"] = uri
+        return _FakeConn()
+
+    client = ws_client.Client("app_id", "app_secret")
+    monkeypatch.setattr(
+        client,
+        "_get_conn_url",
+        lambda: "ws://example.test/callback?device_id=device&service_id=42",
+    )
+    monkeypatch.setattr(ws_client.websockets, "connect", fake_connect)
+    monkeypatch.setattr(
+        ws_client.loop,
+        "create_task",
+        lambda coro: coro.close() if hasattr(coro, "close") else None,
+    )
+
+    await client._connect()
+    await client._disconnect()
+
+    assert captured == {
+        "uri": "ws://example.test/callback?device_id=device&service_id=42",
+    }
diff --git a/lark_channel/ws/tests/test_ws_security.py b/lark_channel/ws/tests/test_ws_security.py
new file mode 100644
index 0000000..51b878f
--- /dev/null
+++ b/lark_channel/ws/tests/test_ws_security.py
@@ -0,0 +1,289 @@
+import asyncio
+import logging
+from types import SimpleNamespace
+
+import pytest
+
+from lark_channel.channel.config import SecurityConfig
+from lark_channel.event.security import (
+    InMemorySecurityAuditRecorder,
+    REASON_WS_FRAGMENT_LIMIT,
+    REASON_WS_INSECURE_SCHEME,
+    REASON_WS_INVALID_TIMING,
+)
+from lark_channel.ws import client as ws_client
+from lark_channel.ws.exception import ClientException
+from lark_channel.ws.model import ClientConfig
+
+
+@pytest.mark.asyncio
+async def test_ws_compat_allows_insecure_endpoint_and_audits(monkeypatch):
+    calls = {}
+    recorder = InMemorySecurityAuditRecorder()
+
+    async def fake_connect(url, **kwargs):
+        calls["url"] = url
+        return SimpleNamespace(close=lambda: None)
+
+    def close_task(coro):
+        coro.close()
+
+    client = ws_client.Client(
+        app_id="cli_x",
+        app_secret="s",
+        security=SecurityConfig(mode="compat", audit_recorder=recorder),
+    )
+    monkeypatch.setattr(
+        client,
+        "_get_conn_url",
+        lambda: "ws://example.test/callback?device_id=device&service_id=42",
+    )
+    monkeypatch.setattr(ws_client.websockets, "connect", fake_connect)
+    monkeypatch.setattr(ws_client, "loop", SimpleNamespace(create_task=close_task))
+
+    await client._connect()
+
+    assert calls["url"].startswith("ws://example.test")
+    assert [event.reason for event in recorder.events] == [REASON_WS_INSECURE_SCHEME]
+
+
+@pytest.mark.asyncio
+async def test_ws_default_compat_allows_insecure_endpoint_without_audit_warning(
+    monkeypatch,
+    caplog,
+):
+    calls = {}
+
+    async def fake_connect(url, **kwargs):
+        calls["url"] = url
+        return SimpleNamespace(close=lambda: None)
+
+    def close_task(coro):
+        coro.close()
+
+    client = ws_client.Client(
+        app_id="cli_x",
+        app_secret="s",
+        security=SecurityConfig(mode="compat"),
+    )
+    monkeypatch.setattr(
+        client,
+        "_get_conn_url",
+        lambda: "ws://example.test/callback?device_id=device&service_id=42",
+    )
+    monkeypatch.setattr(ws_client.websockets, "connect", fake_connect)
+    monkeypatch.setattr(ws_client, "loop", SimpleNamespace(create_task=close_task))
+
+    with caplog.at_level(logging.WARNING, logger="Lark"):
+        await client._connect()
+
+    assert calls["url"].startswith("ws://example.test")
+    assert "security audit" not in caplog.text
+
+
+@pytest.mark.asyncio
+async def test_ws_strict_rejects_insecure_endpoint_before_connect(monkeypatch):
+    recorder = InMemorySecurityAuditRecorder()
+
+    async def fail_connect(*_args, **_kwargs):
+        raise AssertionError("connect should not run")
+
+    client = ws_client.Client(
+        app_id="cli_x",
+        app_secret="s",
+        security=SecurityConfig(mode="strict", audit_recorder=recorder),
+    )
+    monkeypatch.setattr(
+        client,
+        "_get_conn_url",
+        lambda: "ws://example.test/callback?device_id=device&service_id=42",
+    )
+    monkeypatch.setattr(ws_client.websockets, "connect", fail_connect)
+
+    with pytest.raises(ClientException):
+        await client._connect()
+
+    assert [event.reason for event in recorder.events] == [REASON_WS_INSECURE_SCHEME]
+
+
+@pytest.mark.asyncio
+async def test_ws_strict_allow_insecure_endpoint_records_allow_action(monkeypatch):
+    calls = {}
+    recorder = InMemorySecurityAuditRecorder()
+
+    async def fake_connect(url, **kwargs):
+        calls["url"] = url
+        return SimpleNamespace(close=lambda: None)
+
+    def close_task(coro):
+        coro.close()
+
+    client = ws_client.Client(
+        app_id="cli_x",
+        app_secret="s",
+        security=SecurityConfig(
+            mode="strict",
+            allow_insecure_ws=True,
+            audit_recorder=recorder,
+        ),
+    )
+    monkeypatch.setattr(
+        client,
+        "_get_conn_url",
+        lambda: "ws://example.test/callback?device_id=device&service_id=42",
+    )
+    monkeypatch.setattr(ws_client.websockets, "connect", fake_connect)
+    monkeypatch.setattr(ws_client, "loop", SimpleNamespace(create_task=close_task))
+
+    await client._connect()
+
+    assert calls["url"].startswith("ws://example.test")
+    assert [event.reason for event in recorder.events] == [REASON_WS_INSECURE_SCHEME]
+    assert recorder.events[0].action == "allow"
+
+
+@pytest.mark.asyncio
+async def test_ws_strict_allows_local_insecure_endpoint_by_default(monkeypatch):
+    calls = {}
+
+    async def fake_connect(url, **kwargs):
+        calls["url"] = url
+        return SimpleNamespace(close=lambda: None)
+
+    def close_task(coro):
+        coro.close()
+
+    client = ws_client.Client(
+        app_id="cli_x",
+        app_secret="s",
+        security=SecurityConfig(mode="strict"),
+    )
+    monkeypatch.setattr(
+        client,
+        "_get_conn_url",
+        lambda: "ws://127.0.0.1/callback?device_id=device&service_id=42",
+    )
+    monkeypatch.setattr(ws_client.websockets, "connect", fake_connect)
+    monkeypatch.setattr(ws_client, "loop", SimpleNamespace(create_task=close_task))
+
+    await client._connect()
+
+    assert calls["url"].startswith("ws://127.0.0.1")
+
+
+def test_ws_fragment_combine_does_not_preallocate_by_sum():
+    client = ws_client.Client(app_id="cli_x", app_secret="s")
+
+    assert client._combine("msg_1", 10_000_000, 0, b"part") is None
+    cached = client._cache.get("msg_1")
+
+    assert isinstance(cached["parts"], dict)
+    assert cached["sum"] == 10_000_000
+    assert cached["parts"] == {0: b"part"}
+
+
+def test_ws_fragment_limits_are_audited_without_default_drop():
+    recorder = InMemorySecurityAuditRecorder()
+    client = ws_client.Client(
+        app_id="cli_x",
+        app_secret="s",
+        security=SecurityConfig(
+            mode="audit",
+            audit_recorder=recorder,
+            max_ws_fragment_parts=2,
+        ),
+    )
+
+    assert client._combine("msg_1", 3, 0, b"a") is None
+    assert client._combine("msg_1", 3, 1, b"b") is None
+    assert client._combine("msg_1", 3, 2, b"c") == b"abc"
+    assert [event.reason for event in recorder.events] == [
+        REASON_WS_FRAGMENT_LIMIT,
+        REASON_WS_FRAGMENT_LIMIT,
+        REASON_WS_FRAGMENT_LIMIT,
+    ]
+
+
+def test_ws_configure_sanitizes_invalid_timing_values():
+    recorder = InMemorySecurityAuditRecorder()
+    client = ws_client.Client(
+        app_id="cli_x",
+        app_secret="s",
+        security=SecurityConfig(mode="compat", audit_recorder=recorder),
+    )
+    conf = ClientConfig(
+        {
+            "ReconnectCount": -99,
+            "ReconnectInterval": 0,
+            "ReconnectNonce": -1,
+            "PingInterval": 10**12,
+        }
+    )
+
+    client._configure(conf)
+
+    assert client._reconnect_count == -1
+    assert client._reconnect_interval == 120
+    assert client._reconnect_nonce == 30
+    assert client._ping_interval == 120
+    assert [event.reason for event in recorder.events] == [
+        REASON_WS_INVALID_TIMING,
+        REASON_WS_INVALID_TIMING,
+        REASON_WS_INVALID_TIMING,
+        REASON_WS_INVALID_TIMING,
+    ]
+
+
+@pytest.mark.asyncio
+async def test_ws_max_concurrent_handlers_limits_active_message_tasks(monkeypatch):
+    class TwoMessageConn:
+        def __init__(self):
+            self.count = 0
+
+        async def recv(self):
+            self.count += 1
+            if self.count <= 2:
+                return f"message-{self.count}"
+            raise RuntimeError("stop")
+
+    client = ws_client.Client(
+        app_id="cli_x",
+        app_secret="s",
+        auto_reconnect=False,
+        security=SecurityConfig(max_concurrent_ws_handlers=1),
+    )
+    conn = TwoMessageConn()
+    started = []
+    first_started = asyncio.Event()
+    release = asyncio.Event()
+    active = 0
+    max_active = 0
+
+    async def fake_handle_message(message):
+        nonlocal active, max_active
+        active += 1
+        max_active = max(max_active, active)
+        started.append(message)
+        first_started.set()
+        await release.wait()
+        active -= 1
+
+    async def noop_disconnect(*_args, **_kwargs):
+        return None
+
+    monkeypatch.setattr(ws_client, "loop", asyncio.get_running_loop())
+    monkeypatch.setattr(client, "_handle_message", fake_handle_message)
+    monkeypatch.setattr(client, "_disconnect", noop_disconnect)
+
+    task = asyncio.create_task(client._receive_message_loop(conn))
+    await asyncio.wait_for(first_started.wait(), timeout=1)
+    await asyncio.sleep(0.05)
+
+    assert started == ["message-1"]
+    assert max_active == 1
+
+    release.set()
+    with pytest.raises(RuntimeError, match="stop"):
+        await task
+    assert started == ["message-1", "message-2"]
+    assert max_active == 1
diff --git a/pytest.ini b/pytest.ini
new file mode 100644
index 0000000..3cf089f
--- /dev/null
+++ b/pytest.ini
@@ -0,0 +1,17 @@
+[pytest]
+asyncio_mode = auto
+testpaths =
+    lark_channel/channel/tests
+    lark_channel/core/token/tests
+    lark_channel/event/tests
+    lark_channel/ws/tests
+    tests
+python_files = test_*.py
+# Targeted warning filter: FileTokenStore warns loudly on construction; tests
+# that exercise it would otherwise be noisy. We do not blanket-ignore
+# DeprecationWarning here — that would hide real forward-compatibility
+# regressions (e.g. asyncio.get_event_loop() being removed in 3.14).
+filterwarnings =
+    ignore:FileTokenStore is not for production:UserWarning
+markers =
+    slow: marks tests that take non-trivial wall-clock time
diff --git a/samples/channel/echo_bot.py b/samples/channel/echo_bot.py
new file mode 100644
index 0000000..edac7e7
--- /dev/null
+++ b/samples/channel/echo_bot.py
@@ -0,0 +1,35 @@
+import asyncio
+import os
+
+from lark_channel import FeishuChannel
+
+
+def _require_env(name):
+    value = os.environ.get(name)
+    if not value:
+        raise SystemExit(
+            f"Missing {name}. Set it before running, for example: "
+            f"export {name}=your_value"
+        )
+    return value
+
+
+async def main():
+    channel = FeishuChannel(
+        app_id=_require_env("LARK_APP_ID"),
+        app_secret=_require_env("LARK_APP_SECRET"),
+    )
+
+    async def on_message(msg):
+        await channel.send(
+            msg.conversation.chat_id,
+            {"text": f"echo: {msg.content_text}"},
+        )
+
+    channel.on("message", on_message)
+
+    await channel.connect()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/setup.py b/setup.py
new file mode 100644
index 0000000..20960eb
--- /dev/null
+++ b/setup.py
@@ -0,0 +1,63 @@
+import re
+from pathlib import Path
+
+from setuptools import find_packages, setup
+
+_CONST = Path(__file__).parent / "lark_channel" / "core" / "const.py"
+_match = re.search(
+    r'^VERSION\s*=\s*["\']([^"\']+)["\']',
+    _CONST.read_text(encoding="utf-8"),
+    re.M,
+)
+if not _match:
+    raise RuntimeError("VERSION not found in lark_channel/core/const.py")
+VERSION = _match.group(1)
+
+with open("README.md", mode="r", encoding="utf-8") as f:
+    readme = f.read()
+
+setup(
+    name="lark-channel-sdk",
+    version=VERSION,
+    description="Lark Channel SDK for Python",
+    long_description=readme,
+    long_description_content_type="text/markdown",
+    author="Lark Technologies Pte. Ltd.",
+    url="https://github.com/larksuite/channel-sdk-python",
+    license="MIT",
+    packages=find_packages(
+        exclude=["tests", "tests.*", "*.tests", "*.tests.*"],
+    ),
+    install_requires=[
+        "requests>=2.25",
+        "requests_toolbelt>=0.9",
+        "pycryptodome>=3.9",
+        "websockets>=11,<16",
+        "httpx>=0.24,<1.0",
+    ],
+    extras_require={
+        "aiohttp": ["aiohttp>=3.8"],
+        "fastapi": ["fastapi>=0.100", "uvicorn>=0.23"],
+        "flask": ["Flask>=2"],
+        "test": ["build>=1", "pytest>=7", "pytest-asyncio>=0.21"],
+    },
+    python_requires=">=3.8",
+    keywords=["Lark", "Feishu", "Channel", "bot"],
+    include_package_data=True,
+    classifiers=[
+        "Development Status :: 5 - Production/Stable",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+    ],
+    project_urls={
+        "Source": "https://github.com/larksuite/channel-sdk-python",
+    },
+)
diff --git a/tests/bridge/test_active_run_batch.py b/tests/bridge/test_active_run_batch.py
new file mode 100644
index 0000000..8ff74f7
--- /dev/null
+++ b/tests/bridge/test_active_run_batch.py
@@ -0,0 +1,387 @@
+import asyncio
+
+import pytest
+
+from lark_channel import FeishuChannel
+from lark_channel.channel.config import ChatQueueConfig, TextBatchConfig
+from lark_channel.channel.safety.chat_pipeline import ChatPipelineManager
+from lark_channel.channel.safety.pipeline import SafetyPipeline
+from lark_channel.channel.tests.test_safety import _msg
+
+
+@pytest.mark.asyncio
+async def test_blocked_scope_buffers_until_unblocked():
+    loop = asyncio.get_event_loop()
+    manager = ChatPipelineManager(
+        TextBatchConfig(delay_ms=0),
+        loop,
+        ChatQueueConfig(enabled=True),
+    )
+    seen = []
+
+    async def handler(merged, batch):
+        seen.append([m.id for m in batch])
+
+    manager.block_scope("oc_1")
+    manager.push("oc_1", _msg(id="m1", text="a"), handler)
+    await asyncio.sleep(0.01)
+    assert seen == []
+    manager.unblock_scope("oc_1")
+    await manager.dispose()
+    assert seen == [["m1"]]
+
+
+@pytest.mark.asyncio
+async def test_cancel_scope_drops_buffered_messages():
+    loop = asyncio.get_event_loop()
+    manager = ChatPipelineManager(
+        TextBatchConfig(delay_ms=0),
+        loop,
+        ChatQueueConfig(enabled=True),
+    )
+    seen = []
+
+    async def handler(merged, batch):
+        seen.append(batch)
+
+    manager.block_scope("oc_1")
+    manager.push("oc_1", _msg(id="m1", text="a"), handler)
+    manager.cancel_scope("oc_1")
+    manager.unblock_scope("oc_1")
+    await asyncio.sleep(0.01)
+    assert seen == []
+
+
+@pytest.mark.asyncio
+async def test_blocked_scope_does_not_flush_on_message_cap():
+    loop = asyncio.get_event_loop()
+    cfg = TextBatchConfig(delay_ms=1000, max_messages=1)
+    manager = ChatPipelineManager(cfg, loop, ChatQueueConfig(enabled=True))
+    seen = []
+
+    async def handler(merged, batch):
+        seen.append([m.id for m in batch])
+
+    manager.block_scope("oc_1")
+    manager.push("oc_1", _msg(id="m1", text="a"), handler)
+    await asyncio.sleep(0.01)
+    assert seen == []
+    manager.unblock_scope("oc_1")
+    await manager.dispose()
+    assert seen == [["m1"]]
+
+
+@pytest.mark.asyncio
+async def test_blocked_scopes_are_independent():
+    loop = asyncio.get_event_loop()
+    manager = ChatPipelineManager(
+        TextBatchConfig(delay_ms=0),
+        loop,
+        ChatQueueConfig(enabled=True),
+    )
+    seen = []
+
+    async def handler(merged, batch):
+        seen.append([m.id for m in batch])
+
+    manager.block_scope("oc_1")
+    manager.push("oc_1", _msg(id="m1", text="a"), handler)
+    manager.push("oc_2", _msg(id="m2", text="b"), handler)
+    await asyncio.sleep(0.01)
+    manager.cancel_scope("oc_1")
+    await manager.dispose()
+    assert seen == [["m2"]]
+
+
+@pytest.mark.asyncio
+async def test_unblock_respects_existing_quiet_window():
+    loop = asyncio.get_event_loop()
+    manager = ChatPipelineManager(
+        TextBatchConfig(delay_ms=50),
+        loop,
+        ChatQueueConfig(enabled=True),
+    )
+    seen = []
+
+    async def handler(merged, batch):
+        seen.append([m.id for m in batch])
+
+    manager.block_scope("oc_1")
+    manager.push("oc_1", _msg(id="m1", text="a"), handler)
+    manager.unblock_scope("oc_1")
+    await asyncio.sleep(0.01)
+    assert seen == []
+    await manager.dispose()
+    assert seen == [["m1"]]
+
+
+@pytest.mark.asyncio
+async def test_unblock_flushes_immediately_when_buffer_exceeds_cap():
+    loop = asyncio.get_event_loop()
+    manager = ChatPipelineManager(
+        TextBatchConfig(delay_ms=1000, max_messages=2),
+        loop,
+        ChatQueueConfig(enabled=True),
+    )
+    seen = []
+
+    async def handler(merged, batch):
+        seen.append([m.id for m in batch])
+
+    manager.block_scope("oc_1")
+    manager.push("oc_1", _msg(id="m1", text="a"), handler)
+    manager.push("oc_1", _msg(id="m2", text="b"), handler)
+    await asyncio.sleep(0.01)
+    assert seen == []
+    manager.unblock_scope("oc_1")
+    await asyncio.sleep(0.01)
+    assert seen == [["m1", "m2"]]
+
+
+@pytest.mark.asyncio
+async def test_blocked_scope_can_disable_merge_while_busy():
+    loop = asyncio.get_event_loop()
+    manager = ChatPipelineManager(
+        TextBatchConfig(delay_ms=0),
+        loop,
+        ChatQueueConfig(enabled=True, merge_while_busy=False),
+    )
+    seen = []
+
+    async def handler(merged, batch):
+        seen.append([m.id for m in batch])
+
+    manager.block_scope("oc_1")
+    manager.push("oc_1", _msg(id="m1", text="a"), handler)
+    manager.push("oc_1", _msg(id="m2", text="b"), handler)
+    await asyncio.sleep(0.01)
+    assert seen == []
+    manager.unblock_scope("oc_1")
+    await manager.dispose()
+    assert seen == [["m1"], ["m2"]]
+
+
+@pytest.mark.asyncio
+async def test_unmerged_busy_messages_stay_before_deferred_runs():
+    loop = asyncio.get_event_loop()
+    manager = ChatPipelineManager(
+        TextBatchConfig(delay_ms=0),
+        loop,
+        ChatQueueConfig(enabled=True, merge_while_busy=False),
+    )
+    seen = []
+
+    async def handler(merged, batch):
+        seen.append(("message", [m.id for m in batch]))
+
+    async def action():
+        seen.append(("action", []))
+
+    manager.block_scope("oc_1")
+    manager.push("oc_1", _msg(id="m1", text="a"), handler)
+    manager.push("oc_1", _msg(id="m2", text="b"), handler)
+    manager.run("oc_1", action)
+    await asyncio.sleep(0.01)
+    assert seen == []
+    manager.unblock_scope("oc_1")
+    await manager.dispose()
+    assert seen == [
+        ("message", ["m1"]),
+        ("message", ["m2"]),
+        ("action", []),
+    ]
+
+
+@pytest.mark.asyncio
+async def test_unblock_flushes_immediately_when_buffer_exceeds_char_cap():
+    loop = asyncio.get_event_loop()
+    manager = ChatPipelineManager(
+        TextBatchConfig(delay_ms=1000, max_chars=3),
+        loop,
+        ChatQueueConfig(enabled=True),
+    )
+    seen = []
+
+    async def handler(merged, batch):
+        seen.append([m.id for m in batch])
+
+    manager.block_scope("oc_1")
+    manager.push("oc_1", _msg(id="m1", text="ab"), handler)
+    manager.push("oc_1", _msg(id="m2", text="cd"), handler)
+    await asyncio.sleep(0.01)
+    assert seen == []
+    manager.unblock_scope("oc_1")
+    await asyncio.sleep(0.01)
+    assert seen == [["m1", "m2"]]
+
+
+@pytest.mark.asyncio
+async def test_serial_run_waits_behind_blocked_buffer_until_unblock():
+    loop = asyncio.get_event_loop()
+    manager = ChatPipelineManager(
+        TextBatchConfig(delay_ms=0),
+        loop,
+        ChatQueueConfig(enabled=True),
+    )
+    seen = []
+
+    async def handler(merged, batch):
+        seen.append(("message", [m.id for m in batch]))
+
+    async def action():
+        seen.append(("action", []))
+
+    manager.block_scope("oc_1")
+    manager.push("oc_1", _msg(id="m1", text="a"), handler)
+    manager.run("oc_1", action)
+    await asyncio.sleep(0.01)
+    assert seen == []
+    manager.unblock_scope("oc_1")
+    await manager.dispose()
+    assert seen == [("message", ["m1"]), ("action", [])]
+
+
+@pytest.mark.asyncio
+async def test_cancel_blocked_buffer_releases_deferred_run():
+    loop = asyncio.get_event_loop()
+    manager = ChatPipelineManager(
+        TextBatchConfig(delay_ms=0),
+        loop,
+        ChatQueueConfig(enabled=True),
+    )
+    seen = []
+
+    async def handler(merged, batch):
+        seen.append(("message", [m.id for m in batch]))
+
+    async def action():
+        seen.append(("action", []))
+
+    manager.block_scope("oc_1")
+    manager.push("oc_1", _msg(id="m1", text="a"), handler)
+    manager.run("oc_1", action)
+    await asyncio.sleep(0.01)
+    assert seen == []
+    manager.cancel_scope("oc_1")
+    await manager.dispose()
+    assert seen == [("action", [])]
+
+
+@pytest.mark.asyncio
+async def test_run_first_does_not_disable_later_batching():
+    loop = asyncio.get_event_loop()
+    manager = ChatPipelineManager(
+        TextBatchConfig(delay_ms=50, max_messages=10),
+        loop,
+        ChatQueueConfig(enabled=True),
+    )
+    seen = []
+
+    async def action():
+        seen.append(("action", []))
+
+    async def handler(merged, batch):
+        seen.append(("message", [m.id for m in batch]))
+
+    manager.run("oc_1", action)
+    await asyncio.sleep(0.01)
+    manager.push("oc_1", _msg(id="m1", text="a"), handler)
+    manager.push("oc_1", _msg(id="m2", text="b"), handler)
+    await asyncio.sleep(0.01)
+    assert seen == [("action", [])]
+    await manager.dispose()
+    assert seen == [("action", []), ("message", ["m1", "m2"])]
+
+
+@pytest.mark.asyncio
+async def test_safety_pipeline_exposes_batch_scope_controls():
+    loop = asyncio.get_event_loop()
+    seen = []
+
+    async def on_message(msg):
+        seen.append(msg.id)
+
+    pipeline = SafetyPipeline(
+        loop=loop,
+        on_message=on_message,
+        batch_config=TextBatchConfig(delay_ms=0),
+    )
+
+    pipeline.block_batch_scope("oc_1")
+    await pipeline.push_message(_msg(id="m1", chat_id="oc_1", text="a"))
+    await asyncio.sleep(0.01)
+    assert seen == []
+    pipeline.unblock_batch_scope("oc_1")
+    await pipeline.dispose()
+    assert seen == ["m1"]
+
+
+def test_channel_batch_scope_methods_delegate_to_safety(monkeypatch):
+    class FakeLoop:
+        def is_running(self):
+            return False
+
+    class FakeSafety:
+        def __init__(self):
+            self.calls = []
+
+        def block_batch_scope(self, scope):
+            self.calls.append(("block", scope))
+
+        def unblock_batch_scope(self, scope):
+            self.calls.append(("unblock", scope))
+
+        def cancel_batch_scope(self, scope):
+            self.calls.append(("cancel", scope))
+
+    channel = FeishuChannel(app_id="cli_x", app_secret="s")
+    safety = FakeSafety()
+    channel._bg_loop = FakeLoop()
+    channel._safety = safety
+    monkeypatch.setattr(channel, "_ensure_bg_loop", lambda: None)
+
+    channel.block_batch_scope("oc_1")
+    channel.unblock_batch_scope("oc_1")
+    channel.cancel_batch_scope("oc_1")
+
+    assert safety.calls == [
+        ("block", "oc_1"),
+        ("unblock", "oc_1"),
+        ("cancel", "oc_1"),
+    ]
+
+
+@pytest.mark.asyncio
+async def test_channel_batch_scope_call_on_bg_loop_runs_immediately(monkeypatch):
+    class FakeSafety:
+        def __init__(self):
+            self.calls = []
+
+        def block_batch_scope(self, scope):
+            self.calls.append(scope)
+
+    channel = FeishuChannel(app_id="cli_x", app_secret="s")
+    safety = FakeSafety()
+    channel._bg_loop = asyncio.get_running_loop()
+    channel._safety = safety
+    monkeypatch.setattr(channel, "_ensure_bg_loop", lambda: None)
+
+    channel.block_batch_scope("oc_1")
+
+    assert safety.calls == ["oc_1"]
+
+
+def test_channel_batch_scope_rejects_closed_loop(monkeypatch):
+    class FakeSafety:
+        def block_batch_scope(self, scope):
+            raise AssertionError("should not call safety on a closed loop")
+
+    loop = asyncio.new_event_loop()
+    loop.close()
+    channel = FeishuChannel(app_id="cli_x", app_secret="s")
+    channel._bg_loop = loop
+    channel._safety = FakeSafety()
+    monkeypatch.setattr(channel, "_ensure_bg_loop", lambda: None)
+
+    with pytest.raises(RuntimeError, match="background loop is not running"):
+        channel.block_batch_scope("oc_1")
diff --git a/tests/bridge/test_chat_mode_cache.py b/tests/bridge/test_chat_mode_cache.py
new file mode 100644
index 0000000..d858407
--- /dev/null
+++ b/tests/bridge/test_chat_mode_cache.py
@@ -0,0 +1,75 @@
+import pytest
+
+from lark_channel import ChannelConfig, ChatModeCacheConfig, FeishuChannel
+from lark_channel.channel.chat_mode import ChatModeCache
+from lark_channel.channel.types import ChatInfo
+
+
+def test_chat_info_chat_mode_property_reads_raw_without_constructor_break():
+    info = ChatInfo("oc_1", raw={"chat_mode": "thread"})
+    assert info.chat_id == "oc_1"
+    assert info.chat_mode == "thread"
+
+
+@pytest.mark.asyncio
+async def test_get_chat_mode_caches_success(monkeypatch):
+    ch = FeishuChannel(
+        app_id="cli_x",
+        app_secret="s",
+        config=ChannelConfig(chat_mode_cache=ChatModeCacheConfig(enabled=True)),
+    )
+    calls = []
+
+    async def fake_fetch(client, chat_id):
+        calls.append(chat_id)
+        return ChatInfo(chat_id=chat_id, raw={"chat_mode": "thread"})
+
+    monkeypatch.setattr("lark_channel.channel._api_helpers.fetch_chat_info", fake_fetch)
+
+    assert await ch.get_chat_mode("oc_1") == "thread"
+    assert await ch.get_chat_mode("oc_1") == "thread"
+    assert calls == ["oc_1"]
+
+
+@pytest.mark.asyncio
+async def test_get_chat_mode_fallback_group_does_not_pollute_cache(monkeypatch):
+    ch = FeishuChannel(
+        app_id="cli_x",
+        app_secret="s",
+        config=ChannelConfig(chat_mode_cache=ChatModeCacheConfig(fallback="group")),
+    )
+
+    async def fake_fetch(client, chat_id):
+        return None
+
+    monkeypatch.setattr("lark_channel.channel._api_helpers.fetch_chat_info", fake_fetch)
+
+    assert await ch.get_chat_mode("oc_1") == "group"
+    assert "oc_1" not in ch._chat_mode_cache._values
+
+
+def test_chat_mode_cache_lru_and_ttl(monkeypatch):
+    now = [100.0]
+    monkeypatch.setattr("lark_channel.channel.chat_mode.time.time", lambda: now[0])
+    cache = ChatModeCache(ChatModeCacheConfig(max_size=2, ttl_seconds=10))
+
+    cache.set("oc_1", "group")
+    cache.set("oc_2", "topic")
+    assert cache.get("oc_1") == "group"
+
+    cache.set("oc_3", "thread")
+    assert cache.get("oc_2") is None
+    assert cache.get("oc_1") == "group"
+
+    now[0] = 111.0
+    assert cache.get("oc_1") is None
+
+
+def test_chat_mode_cache_non_positive_max_size_disables_writes():
+    cache = ChatModeCache(ChatModeCacheConfig(max_size=0))
+    cache.set("oc_1", "group")
+    assert cache.get("oc_1") is None
+
+    cache = ChatModeCache(ChatModeCacheConfig(max_size=-1))
+    cache.set("oc_1", "group")
+    assert cache.get("oc_1") is None
diff --git a/tests/bridge/test_media_cache.py b/tests/bridge/test_media_cache.py
new file mode 100644
index 0000000..186711c
--- /dev/null
+++ b/tests/bridge/test_media_cache.py
@@ -0,0 +1,527 @@
+import asyncio
+import io
+import os
+import time
+from dataclasses import fields
+from types import SimpleNamespace
+from typing import List, get_type_hints
+
+import pytest
+
+from lark_channel import ChannelConfig, FeishuChannel, MediaCacheConfig
+from lark_channel.channel import _api_helpers
+from lark_channel.channel.types import CachedResource, ResourceDescriptor
+
+
+def test_media_cache_config_is_appended_for_positional_compatibility():
+    names = [field.name for field in fields(ChannelConfig)]
+
+    assert names[-2:] == ["media_cache", "security"]
+    assert names[names.index("chat_mode_cache") + 1] == "policy"
+
+
+@pytest.mark.asyncio
+async def test_cache_api_writes_hash_named_file(tmp_path, monkeypatch):
+    ch = FeishuChannel(
+        app_id="cli_x",
+        app_secret="s",
+        config=ChannelConfig(media_cache=MediaCacheConfig(root_dir=tmp_path)),
+    )
+
+    async def fake_download(lark_client, *, message_id, file_key, resource_type):
+        assert lark_client is ch.client
+        assert (message_id, file_key, resource_type) == ("om_1", "img_1", "image")
+        return b"abc", "image/png"
+
+    monkeypatch.setattr("lark_channel.channel._api_helpers.download_media_with_meta", fake_download)
+
+    result = await ch.resolve_resource_to_cache(
+        message_id="om_1",
+        resource=ResourceDescriptor(type="image", file_key="img_1"),
+    )
+
+    assert result.decision == "cached"
+    assert result.sha256 == "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+    assert result.path.exists()
+    assert result.path.read_bytes() == b"abc"
+
+
+@pytest.mark.asyncio
+async def test_cache_rejects_sticker_without_downloading(tmp_path, monkeypatch):
+    ch = FeishuChannel(
+        app_id="cli_x",
+        app_secret="s",
+        config=ChannelConfig(media_cache=MediaCacheConfig(root_dir=tmp_path)),
+    )
+    called = False
+
+    async def fake_download(*args, **kwargs):
+        nonlocal called
+        called = True
+        return b"abc", "image/png"
+
+    monkeypatch.setattr("lark_channel.channel._api_helpers.download_media_with_meta", fake_download)
+
+    result = await ch.resolve_resource_to_cache(
+        message_id="om_1",
+        resource=ResourceDescriptor(type="sticker", file_key="st_1"),
+    )
+
+    assert result.decision == "rejected"
+    assert result.reason == "unsupported_resource_type"
+    assert called is False
+
+
+@pytest.mark.asyncio
+async def test_old_download_resource_still_returns_bytes(monkeypatch):
+    ch = FeishuChannel(app_id="cli_x", app_secret="s")
+
+    async def fake_download(*args, **kwargs):
+        return b"old"
+
+    monkeypatch.setattr("lark_channel.channel._api_helpers.download_media", fake_download)
+
+    assert await ch.download_resource("k", "image", "om_1") == b"old"
+
+
+@pytest.mark.asyncio
+async def test_cache_hit_does_not_download_again(tmp_path, monkeypatch):
+    ch = FeishuChannel(
+        app_id="cli_x",
+        app_secret="s",
+        config=ChannelConfig(media_cache=MediaCacheConfig(root_dir=tmp_path)),
+    )
+    calls = 0
+
+    async def fake_download(lark_client, *, message_id, file_key, resource_type):
+        nonlocal calls
+        calls += 1
+        return b"abc", "image/png"
+
+    monkeypatch.setattr("lark_channel.channel._api_helpers.download_media_with_meta", fake_download)
+    resource = ResourceDescriptor(type="image", file_key="img_1")
+
+    first = await ch.resolve_resource_to_cache(message_id="om_1", resource=resource)
+    second = await ch.resolve_resource_to_cache(message_id="om_1", resource=resource)
+
+    assert first.path == second.path
+    assert calls == 1
+
+
+@pytest.mark.asyncio
+async def test_cache_hit_revalidates_file_content(tmp_path, monkeypatch):
+    ch = FeishuChannel(
+        app_id="cli_x",
+        app_secret="s",
+        config=ChannelConfig(media_cache=MediaCacheConfig(root_dir=tmp_path)),
+    )
+    calls = 0
+
+    async def fake_download(lark_client, *, message_id, file_key, resource_type):
+        nonlocal calls
+        calls += 1
+        return b"abc", "image/png"
+
+    monkeypatch.setattr("lark_channel.channel._api_helpers.download_media_with_meta", fake_download)
+    resource = ResourceDescriptor(type="image", file_key="img_1")
+
+    first = await ch.resolve_resource_to_cache(message_id="om_1", resource=resource)
+    first.path.write_bytes(b"bad")
+    second = await ch.resolve_resource_to_cache(message_id="om_1", resource=resource)
+
+    assert calls == 2
+    assert second.decision == "cached"
+    assert second.path.read_bytes() == b"abc"
+
+
+@pytest.mark.asyncio
+async def test_zero_byte_cache_hit_is_valid(tmp_path, monkeypatch):
+    ch = FeishuChannel(
+        app_id="cli_x",
+        app_secret="s",
+        config=ChannelConfig(media_cache=MediaCacheConfig(root_dir=tmp_path)),
+    )
+    calls = 0
+
+    async def fake_download(lark_client, *, message_id, file_key, resource_type):
+        nonlocal calls
+        calls += 1
+        return b"", "application/octet-stream"
+
+    monkeypatch.setattr("lark_channel.channel._api_helpers.download_media_with_meta", fake_download)
+    resource = ResourceDescriptor(type="file", file_key="file_1")
+
+    first = await ch.resolve_resource_to_cache(message_id="om_1", resource=resource)
+    second = await ch.resolve_resource_to_cache(message_id="om_1", resource=resource)
+
+    assert calls == 1
+    assert first.path == second.path
+    assert second.size == 0
+    assert second.path.exists()
+
+
+@pytest.mark.asyncio
+async def test_expired_cache_hit_downloads_fresh_file(tmp_path, monkeypatch):
+    ch = FeishuChannel(
+        app_id="cli_x",
+        app_secret="s",
+        config=ChannelConfig(
+            media_cache=MediaCacheConfig(root_dir=tmp_path, ttl_seconds=1)
+        ),
+    )
+    bodies = [b"abc", b"def"]
+    calls = 0
+
+    async def fake_download(lark_client, *, message_id, file_key, resource_type):
+        nonlocal calls
+        body = bodies[calls]
+        calls += 1
+        return body, "image/png"
+
+    monkeypatch.setattr("lark_channel.channel._api_helpers.download_media_with_meta", fake_download)
+    resource = ResourceDescriptor(type="image", file_key="img_1")
+
+    first = await ch.resolve_resource_to_cache(message_id="om_1", resource=resource)
+    old_time = time.time() - 10
+    os.utime(first.path, (old_time, old_time))
+    second = await ch.resolve_resource_to_cache(message_id="om_1", resource=resource)
+
+    assert calls == 2
+    assert first.path != second.path
+    assert not first.path.exists()
+    assert second.path.exists()
+    assert second.path.read_bytes() == b"def"
+
+
+@pytest.mark.asyncio
+async def test_cache_rejects_oversized_image_and_unknown_mime(tmp_path, monkeypatch):
+    ch = FeishuChannel(
+        app_id="cli_x",
+        app_secret="s",
+        config=ChannelConfig(
+            media_cache=MediaCacheConfig(root_dir=tmp_path, image_max_bytes=2)
+        ),
+    )
+
+    async def too_large(lark_client, *, message_id, file_key, resource_type):
+        return b"abc", "image/png"
+
+    monkeypatch.setattr("lark_channel.channel._api_helpers.download_media_with_meta", too_large)
+    result = await ch.resolve_resource_to_cache(
+        message_id="om_1",
+        resource=ResourceDescriptor(type="image", file_key="img_1"),
+    )
+    assert result.decision == "rejected"
+    assert result.reason == "image_max_bytes"
+
+    async def bad_mime(lark_client, *, message_id, file_key, resource_type):
+        return b"a", "application/octet-stream"
+
+    monkeypatch.setattr("lark_channel.channel._api_helpers.download_media_with_meta", bad_mime)
+    result = await ch.resolve_resource_to_cache(
+        message_id="om_1",
+        resource=ResourceDescriptor(type="image", file_key="img_2"),
+    )
+    assert result.reason == "unsupported_mime_type"
+
+
+@pytest.mark.asyncio
+async def test_cache_skips_impossible_retention_limits_without_downloading(tmp_path, monkeypatch):
+    ch = FeishuChannel(
+        app_id="cli_x",
+        app_secret="s",
+        config=ChannelConfig(
+            media_cache=MediaCacheConfig(root_dir=tmp_path, max_entries=0)
+        ),
+    )
+    called = False
+
+    async def fake_download(*args, **kwargs):
+        nonlocal called
+        called = True
+        return b"abc", "image/png"
+
+    monkeypatch.setattr("lark_channel.channel._api_helpers.download_media_with_meta", fake_download)
+
+    result = await ch.resolve_resource_to_cache(
+        message_id="om_1",
+        resource=ResourceDescriptor(type="image", file_key="img_1"),
+    )
+
+    assert result.decision == "skipped"
+    assert result.reason == "cache_limit"
+    assert result.path is None
+    assert called is False
+
+
+@pytest.mark.asyncio
+async def test_cache_skips_negative_retention_limits_without_error(tmp_path, monkeypatch):
+    ch = FeishuChannel(
+        app_id="cli_x",
+        app_secret="s",
+        config=ChannelConfig(
+            media_cache=MediaCacheConfig(root_dir=tmp_path, max_entries=-1)
+        ),
+    )
+    called = False
+
+    async def fake_download(*args, **kwargs):
+        nonlocal called
+        called = True
+        return b"abc", "image/png"
+
+    monkeypatch.setattr("lark_channel.channel._api_helpers.download_media_with_meta", fake_download)
+
+    result = await ch.resolve_resource_to_cache(
+        message_id="om_1",
+        resource=ResourceDescriptor(type="image", file_key="img_1"),
+    )
+
+    assert result.decision == "skipped"
+    assert result.reason == "cache_limit"
+    assert result.path is None
+    assert called is False
+
+
+@pytest.mark.asyncio
+async def test_cache_rejects_file_larger_than_total_cache_limit(tmp_path, monkeypatch):
+    ch = FeishuChannel(
+        app_id="cli_x",
+        app_secret="s",
+        config=ChannelConfig(media_cache=MediaCacheConfig(root_dir=tmp_path, max_bytes=2)),
+    )
+
+    async def fake_download(lark_client, *, message_id, file_key, resource_type):
+        return b"abc", "application/octet-stream"
+
+    monkeypatch.setattr("lark_channel.channel._api_helpers.download_media_with_meta", fake_download)
+
+    result = await ch.resolve_resource_to_cache(
+        message_id="om_1",
+        resource=ResourceDescriptor(type="file", file_key="file_1"),
+    )
+
+    assert result.decision == "rejected"
+    assert result.reason == "max_bytes"
+    assert result.path is None
+    assert [p for p in tmp_path.iterdir() if p.is_file()] == []
+
+
+@pytest.mark.asyncio
+async def test_cache_write_failure_cleans_temp_file(tmp_path, monkeypatch):
+    ch = FeishuChannel(
+        app_id="cli_x",
+        app_secret="s",
+        config=ChannelConfig(media_cache=MediaCacheConfig(root_dir=tmp_path)),
+    )
+
+    async def fake_download(lark_client, *, message_id, file_key, resource_type):
+        return b"abc", "image/png"
+
+    def failing_replace(src, dst):
+        raise OSError("replace failed")
+
+    monkeypatch.setattr("lark_channel.channel._api_helpers.download_media_with_meta", fake_download)
+    monkeypatch.setattr("lark_channel.channel.media_cache.os.replace", failing_replace)
+
+    result = await ch.resolve_resource_to_cache(
+        message_id="om_1",
+        resource=ResourceDescriptor(type="image", file_key="img_1"),
+    )
+
+    assert result.decision == "rejected"
+    assert result.reason == "write_failed"
+    assert result.path is None
+    assert list(tmp_path.iterdir()) == []
+
+
+@pytest.mark.asyncio
+async def test_cache_replaces_existing_digest_file_with_wrong_content(tmp_path, monkeypatch):
+    ch = FeishuChannel(
+        app_id="cli_x",
+        app_secret="s",
+        config=ChannelConfig(media_cache=MediaCacheConfig(root_dir=tmp_path)),
+    )
+    digest = "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+    poisoned = tmp_path / f"{digest}.png"
+    poisoned.write_bytes(b"bad")
+
+    async def fake_download(lark_client, *, message_id, file_key, resource_type):
+        return b"abc", "image/png"
+
+    monkeypatch.setattr("lark_channel.channel._api_helpers.download_media_with_meta", fake_download)
+
+    result = await ch.resolve_resource_to_cache(
+        message_id="om_1",
+        resource=ResourceDescriptor(type="image", file_key="img_1"),
+    )
+
+    assert result.decision == "cached"
+    assert result.path == poisoned
+    assert result.path.read_bytes() == b"abc"
+
+
+def test_cache_gc_makes_progress_when_unlink_fails(tmp_path, monkeypatch):
+    ch = FeishuChannel(
+        app_id="cli_x",
+        app_secret="s",
+        config=ChannelConfig(media_cache=MediaCacheConfig(root_dir=tmp_path, max_entries=1)),
+    )
+    old = tmp_path / "old.bin"
+    new = tmp_path / "new.bin"
+    old.write_bytes(b"old")
+    new.write_bytes(b"new")
+    calls = 0
+
+    def entries():
+        nonlocal calls
+        calls += 1
+        if calls > 3:
+            raise AssertionError("gc did not make progress")
+        return [old, new]
+
+    monkeypatch.setattr(ch._media_cache, "_entries", entries)
+    monkeypatch.setattr(ch._media_cache, "_safe_unlink", lambda path: False)
+
+    ch._media_cache.gc(protect=new)
+
+    assert calls <= 3
+
+
+@pytest.mark.asyncio
+async def test_cache_accepts_image_filename_hint(tmp_path, monkeypatch):
+    ch = FeishuChannel(
+        app_id="cli_x",
+        app_secret="s",
+        config=ChannelConfig(media_cache=MediaCacheConfig(root_dir=tmp_path)),
+    )
+
+    async def fake_download(lark_client, *, message_id, file_key, resource_type):
+        return b"abc", "photo.png"
+
+    monkeypatch.setattr("lark_channel.channel._api_helpers.download_media_with_meta", fake_download)
+
+    result = await ch.resolve_resource_to_cache(
+        message_id="om_1",
+        resource=ResourceDescriptor(type="image", file_key="img_1"),
+    )
+
+    assert result.decision == "cached"
+    assert result.mime_type == "image/png"
+
+
+@pytest.mark.asyncio
+async def test_cache_sniffs_image_mime_when_server_meta_is_generic(tmp_path, monkeypatch):
+    ch = FeishuChannel(
+        app_id="cli_x",
+        app_secret="s",
+        config=ChannelConfig(media_cache=MediaCacheConfig(root_dir=tmp_path)),
+    )
+    png = (
+        b"\x89PNG\r\n\x1a\n"
+        b"\x00\x00\x00\rIHDR"
+        b"\x00\x00\x00\x01\x00\x00\x00\x01"
+        b"\x08\x02\x00\x00\x00"
+    )
+
+    async def fake_download(lark_client, *, message_id, file_key, resource_type):
+        return png, "application/octet-stream"
+
+    monkeypatch.setattr("lark_channel.channel._api_helpers.download_media_with_meta", fake_download)
+
+    result = await ch.resolve_resource_to_cache(
+        message_id="om_1",
+        resource=ResourceDescriptor(type="image", file_key="img_1"),
+    )
+
+    assert result.decision == "cached"
+    assert result.mime_type == "image/png"
+    assert result.path.suffix == ".png"
+
+
+@pytest.mark.asyncio
+async def test_download_media_with_meta_does_not_block_event_loop_when_generated_get_blocks():
+    class BlockingMessageResource:
+        def get(self, request):
+            time.sleep(0.3)
+            return SimpleNamespace(
+                code=0,
+                file=io.BytesIO(b"image-body"),
+                file_name="image.png",
+            )
+
+    lark_client = SimpleNamespace(
+        im=SimpleNamespace(
+            v1=SimpleNamespace(
+                message_resource=BlockingMessageResource(),
+            )
+        )
+    )
+
+    started = time.monotonic()
+    task = asyncio.create_task(
+        _api_helpers.download_media_with_meta(
+            lark_client,
+            message_id="om_1",
+            file_key="img_1",
+            resource_type="image",
+        )
+    )
+
+    await asyncio.sleep(0.05)
+
+    assert time.monotonic() - started < 0.2
+    body, meta = await asyncio.wait_for(task, timeout=1)
+    assert body == b"image-body"
+    assert meta == "image.png"
+
+
+@pytest.mark.asyncio
+async def test_cache_gc_enforces_ttl_entries_and_bytes(tmp_path, monkeypatch):
+    ch = FeishuChannel(
+        app_id="cli_x",
+        app_secret="s",
+        config=ChannelConfig(
+            media_cache=MediaCacheConfig(
+                root_dir=tmp_path,
+                ttl_seconds=1,
+                max_entries=1,
+                max_bytes=4,
+            )
+        ),
+    )
+
+    async def fake_download(lark_client, *, message_id, file_key, resource_type):
+        return file_key[:3].encode(), "application/octet-stream"
+
+    monkeypatch.setattr("lark_channel.channel._api_helpers.download_media_with_meta", fake_download)
+
+    old = await ch.resolve_resource_to_cache(
+        message_id="om_1",
+        resource=ResourceDescriptor(type="file", file_key="old"),
+    )
+    old_time = time.time() - 10
+    os.utime(old.path, (old_time, old_time))
+
+    newer = await ch.resolve_resource_to_cache(
+        message_id="om_2",
+        resource=ResourceDescriptor(type="file", file_key="newer"),
+    )
+
+    live_files = [
+        p for p in tmp_path.iterdir() if p.is_file() and not p.name.startswith(".")
+    ]
+    assert newer.decision == "cached"
+    assert newer.path.exists()
+    assert not old.path.exists()
+    assert live_files == [newer.path]
+
+
+def test_cache_public_method_type_hints_are_resolvable():
+    single = get_type_hints(FeishuChannel.resolve_resource_to_cache)
+    batch = get_type_hints(FeishuChannel.resolve_resources_to_cache)
+
+    assert single["resource"] is ResourceDescriptor
+    assert single["return"] is CachedResource
+    assert batch["resources"] == List[ResourceDescriptor]
+    assert batch["return"] == List[CachedResource]
diff --git a/tests/bridge/test_quote_resolver.py b/tests/bridge/test_quote_resolver.py
new file mode 100644
index 0000000..1feb6c7
--- /dev/null
+++ b/tests/bridge/test_quote_resolver.py
@@ -0,0 +1,265 @@
+from types import SimpleNamespace
+
+import pytest
+
+from lark_channel import FeishuChannel
+from lark_channel.channel import _api_helpers
+from lark_channel.channel.quote import QuoteResolver
+from lark_channel.channel.types import (
+    Conversation,
+    Identity,
+    InboundMessage,
+    ReplyRef,
+    TextContent,
+)
+
+
+def _msg(mid, parent=None, root=None):
+    return InboundMessage(
+        id=mid,
+        create_time=1,
+        conversation=Conversation(chat_id="oc_1", chat_type="group"),
+        sender=Identity(open_id="ou_1"),
+        content=TextContent(text=mid),
+        reply=ReplyRef(message_id=parent) if parent else None,
+        raw={"message": {"message_id": mid, "parent_id": parent, "root_id": root}},
+    )
+
+
+def _pipeline_raw_msg(mid, parent=None, root=None):
+    return InboundMessage(
+        id=mid,
+        create_time=1,
+        conversation=Conversation(chat_id="oc_1", chat_type="group"),
+        sender=Identity(open_id="ou_1"),
+        content=TextContent(text=mid),
+        reply=ReplyRef(message_id=parent) if parent else None,
+        raw={"message_id": mid, "parent_id": parent, "root_id": root},
+    )
+
+
+@pytest.mark.asyncio
+async def test_batch_quote_skips_parent_inside_same_batch():
+    calls = []
+    resolver = QuoteResolver(fetcher=lambda message_id: calls.append(message_id) or None)
+
+    result = await resolver.resolve_quoted_contexts(
+        [_msg("m1"), _msg("m2", parent="m1")],
+        chat_mode="group",
+    )
+
+    assert result["m2"].decision == "in_batch"
+    assert calls == []
+
+
+@pytest.mark.asyncio
+async def test_duplicate_parent_fetched_once():
+    calls = []
+
+    async def fetch(message_id):
+        calls.append(message_id)
+        return {
+            "message_id": message_id,
+            "msg_type": "text",
+            "content": {"text": "parent"},
+        }
+
+    resolver = QuoteResolver(fetcher=fetch)
+    result = await resolver.resolve_quoted_contexts(
+        [_msg("m2", "p1"), _msg("m3", "p1")],
+        chat_mode="group",
+    )
+
+    assert calls == ["p1"]
+    assert result["m2"].context.text == "parent"
+    assert result["m3"].context.text == "parent"
+
+
+@pytest.mark.asyncio
+async def test_topic_root_anchor_is_not_quote():
+    resolver = QuoteResolver(fetcher=lambda message_id: {"message_id": message_id})
+
+    result = await resolver.resolve_quoted_contexts(
+        [_msg("m2", parent="root_1", root="root_1")],
+        chat_mode="topic",
+    )
+
+    assert result["m2"].decision == "topic_root"
+
+
+@pytest.mark.asyncio
+async def test_thread_mode_topic_root_anchor_reads_pipeline_raw_shape():
+    calls = []
+    resolver = QuoteResolver(fetcher=lambda message_id: calls.append(message_id) or None)
+
+    result = await resolver.resolve_quoted_contexts(
+        [_pipeline_raw_msg("m2", parent="root_1", root="root_1")],
+        chat_mode="thread",
+    )
+
+    assert result["m2"].decision == "topic_root"
+    assert calls == []
+
+
+@pytest.mark.asyncio
+async def test_topic_root_wins_even_when_root_message_is_in_same_batch():
+    calls = []
+    resolver = QuoteResolver(fetcher=lambda message_id: calls.append(message_id) or None)
+
+    result = await resolver.resolve_quoted_contexts(
+        [
+            _pipeline_raw_msg("root_1"),
+            _pipeline_raw_msg("m2", parent="root_1", root="root_1"),
+        ],
+        chat_mode="topic",
+    )
+
+    assert result["m2"].decision == "topic_root"
+    assert calls == []
+
+
+@pytest.mark.asyncio
+async def test_json_text_content_is_flattened():
+    async def fetch(message_id):
+        return {
+            "message_id": message_id,
+            "msg_type": "text",
+            "content": "{\"text\":\"parent\"}",
+        }
+
+    resolver = QuoteResolver(fetcher=fetch)
+    result = await resolver.resolve_quoted_contexts([_msg("m2", "p1")], chat_mode="group")
+
+    assert result["m2"].context.text == "parent"
+
+
+@pytest.mark.asyncio
+async def test_interactive_and_merge_forward_content_are_flattened():
+    interactive = QuoteResolver(
+        fetcher=lambda message_id: {
+            "message_id": message_id,
+            "msg_type": "interactive",
+            "content": "{\"title\":\"card title\",\"elements\":[{\"tag\":\"div\",\"text\":{\"content\":\"card body\"}}]}",
+        }
+    )
+    result = await interactive.resolve_quoted_contexts([_msg("m2", "p1")], chat_mode="group")
+    assert "card title" in result["m2"].context.text
+    assert "card body" in result["m2"].context.text
+
+    merge = QuoteResolver(
+        fetcher=lambda message_id: {
+            "message_id": message_id,
+            "msg_type": "merge_forward",
+            "content": "{\"messages\":[{\"content\":{\"text\":\"forwarded text\"}}]}",
+        }
+    )
+    result = await merge.resolve_quoted_contexts([_msg("m3", "p2")], chat_mode="group")
+    assert "forwarded text" in result["m3"].context.text
+
+
+@pytest.mark.asyncio
+async def test_fetch_failure_keeps_fetch_failed_decision():
+    async def fetch(message_id):
+        raise RuntimeError("permission denied")
+
+    resolver = QuoteResolver(fetcher=fetch)
+    result = await resolver.resolve_quoted_contexts([_msg("m2", "p1")], chat_mode="group")
+
+    assert result["m2"].decision == "fetch_failed"
+    assert result["m2"].context is None
+
+
+@pytest.mark.asyncio
+async def test_message_object_body_content_is_normalized():
+    raw = SimpleNamespace(
+        message_id="p1",
+        msg_type="text",
+        body=SimpleNamespace(content="{\"text\":\"body text\"}"),
+        sender=SimpleNamespace(open_id="ou_1"),
+    )
+    resolver = QuoteResolver(fetcher=lambda message_id: raw)
+
+    result = await resolver.resolve_quoted_contexts([_msg("m2", "p1")], chat_mode="group")
+
+    assert result["m2"].context.text == "body text"
+    assert result["m2"].context.sender_id == "ou_1"
+
+
+@pytest.mark.asyncio
+async def test_message_object_sender_id_is_normalized_from_get_message_shape():
+    raw = {
+        "data": {
+            "items": [
+                {
+                    "message_id": "p1",
+                    "msg_type": "text",
+                    "body": {"content": "{\"text\":\"body text\"}"},
+                    "sender": {"id": "ou_2", "id_type": "open_id"},
+                }
+            ]
+        }
+    }
+    resolver = QuoteResolver(fetcher=lambda message_id: raw)
+
+    result = await resolver.resolve_quoted_contexts([_msg("m2", "p1")], chat_mode="group")
+
+    assert result["m2"].context.sender_id == "ou_2"
+
+
+@pytest.mark.asyncio
+async def test_channel_fetch_message_raw_dict_failure_keeps_fetch_failed(monkeypatch):
+    ch = FeishuChannel(app_id="cli_x", app_secret="s")
+
+    async def fake_fetch(client, message_id, *, card_content_type=None):
+        assert card_content_type == "user_card_content"
+        return {"code": 999, "msg": "permission denied"}
+
+    monkeypatch.setattr("lark_channel.channel._api_helpers.fetch_message_raw", fake_fetch)
+
+    result = await ch.resolve_quoted_contexts([_msg("m2", "p1")], chat_mode="group")
+
+    assert result["m2"].decision == "fetch_failed"
+    assert result["m2"].context is None
+
+
+@pytest.mark.asyncio
+async def test_fetch_message_raw_handles_dict_and_object_codes():
+    class FakeMessage:
+        def __init__(self, response):
+            self._response = response
+            self.requests = []
+
+        async def aget(self, request):
+            self.requests.append(request)
+            return self._response
+
+    class FakeClient:
+        def __init__(self, response):
+            self.im = SimpleNamespace(
+                v1=SimpleNamespace(message=FakeMessage(response))
+            )
+
+    failure = await _api_helpers.fetch_message_raw(FakeClient({"code": 999}), "om_1")
+    assert failure is None
+
+    success_response = SimpleNamespace(
+        code=0,
+        data=SimpleNamespace(
+            items=[
+                SimpleNamespace(
+                    message_id="om_1",
+                    body=SimpleNamespace(content="{\"text\":\"ok\"}"),
+                )
+            ]
+        ),
+    )
+    client = FakeClient(success_response)
+    success = await _api_helpers.fetch_message_raw(
+        client,
+        "om_1",
+        card_content_type="user_card_content",
+    )
+
+    assert success["code"] == 0
+    assert success["data"]["items"][0]["message_id"] == "om_1"
+    assert ("card_msg_content_type", "user_card_content") in client.im.v1.message.requests[0].queries
diff --git a/tests/bridge/test_transport_proxy_timeout.py b/tests/bridge/test_transport_proxy_timeout.py
new file mode 100644
index 0000000..82b9775
--- /dev/null
+++ b/tests/bridge/test_transport_proxy_timeout.py
@@ -0,0 +1,146 @@
+from types import SimpleNamespace
+
+import pytest
+
+from lark_channel import (
+    CachedResource,
+    ChatModeCacheConfig,
+    CommentContext,
+    CommentTarget,
+    FeishuChannel,
+    KeepaliveConfig,
+    MediaCacheConfig,
+    QuotedContext,
+    QuoteResolution,
+    TransportConfig,
+)
+import lark_channel
+from lark_channel import channel as channel_exports
+from lark_channel.core.enum import HttpMethod
+from lark_channel.core.http import transport as http_transport
+from lark_channel.core.model import BaseRequest, Config
+
+
+def _request():
+    req = BaseRequest()
+    req.http_method = HttpMethod.GET
+    req.uri = "/open-apis/ping"
+    req.token_types = set()
+    return req
+
+
+def test_package_root_reexports_bridge_public_types():
+    exports = {
+        "CachedResource": CachedResource,
+        "ChatModeCacheConfig": ChatModeCacheConfig,
+        "CommentContext": CommentContext,
+        "CommentTarget": CommentTarget,
+        "KeepaliveConfig": KeepaliveConfig,
+        "MediaCacheConfig": MediaCacheConfig,
+        "QuotedContext": QuotedContext,
+        "QuoteResolution": QuoteResolution,
+    }
+    for name, exported in exports.items():
+        assert exported is getattr(channel_exports, name)
+        assert exported is getattr(lark_channel, name)
+        assert name in lark_channel.__all__
+
+
+def test_channel_passes_http_timeout_to_client_config():
+    ch = FeishuChannel(
+        app_id="cli_x",
+        app_secret="s",
+        transport=TransportConfig(http_timeout_seconds=12.5),
+    )
+    assert ch.client.config.timeout == 12.5
+
+
+def test_channel_default_timeout_matches_existing_client_default():
+    ch = FeishuChannel(app_id="cli_x", app_secret="s")
+    assert ch.client.config.timeout == 30
+
+
+def test_sync_transport_uses_explicit_proxy(monkeypatch):
+    calls = {}
+
+    def fake_request(method, url, **kwargs):
+        calls.update(kwargs)
+        return SimpleNamespace(status_code=200, headers={"Content-Type": "application/json"}, content=b'{"code":0}')
+
+    monkeypatch.setattr(http_transport.requests, "request", fake_request)
+    conf = Config()
+    conf.proxy_url = "http://127.0.0.1:8080"
+    http_transport.Transport.execute(conf, _request())
+    assert calls["proxies"] == {
+        "http": "http://127.0.0.1:8080",
+        "https": "http://127.0.0.1:8080",
+    }
+
+
+def test_sync_transport_disables_env_proxy_with_session(monkeypatch):
+    calls = {}
+
+    class FakeSession:
+        trust_env = True
+
+        def request(self, method, url, **kwargs):
+            calls["trust_env"] = self.trust_env
+            calls["kwargs"] = kwargs
+            return SimpleNamespace(status_code=200, headers={"Content-Type": "application/json"}, content=b'{"code":0}')
+
+    monkeypatch.setattr(http_transport.requests, "Session", lambda: FakeSession())
+    conf = Config()
+    conf.trust_env_proxy = False
+    http_transport.Transport.execute(conf, _request())
+    assert calls["trust_env"] is False
+    assert "trust_env" not in calls["kwargs"]
+
+
+@pytest.mark.asyncio
+async def test_async_transport_disables_env_when_requested(monkeypatch):
+    captured = {}
+
+    class FakeAsyncClient:
+        def __init__(self, **kwargs):
+            captured.update(kwargs)
+
+        async def __aenter__(self):
+            return self
+
+        async def __aexit__(self, exc_type, exc, tb):
+            return False
+
+        async def request(self, *args, **kwargs):
+            return SimpleNamespace(status_code=200, headers={"Content-Type": "application/json"}, content=b'{"code":0}')
+
+    monkeypatch.setattr(http_transport.httpx, "AsyncClient", FakeAsyncClient)
+    conf = Config()
+    conf.trust_env_proxy = False
+    await http_transport.Transport.aexecute(conf, _request())
+    assert captured["trust_env"] is False
+
+
+def test_httpx_client_kwargs_uses_proxy_parameter(monkeypatch):
+    class FakeAsyncClient:
+        def __init__(self, *, proxy=None, trust_env=True):
+            pass
+
+    monkeypatch.setattr(http_transport.httpx, "AsyncClient", FakeAsyncClient)
+
+    conf = Config()
+    conf.proxy_url = "http://127.0.0.1:8080"
+
+    assert http_transport._httpx_client_kwargs(conf)["proxy"] == "http://127.0.0.1:8080"
+
+
+def test_httpx_client_kwargs_uses_legacy_proxies_parameter(monkeypatch):
+    class FakeAsyncClient:
+        def __init__(self, *, proxies=None, trust_env=True):
+            pass
+
+    monkeypatch.setattr(http_transport.httpx, "AsyncClient", FakeAsyncClient)
+
+    conf = Config()
+    conf.proxy_url = "http://127.0.0.1:8080"
+
+    assert http_transport._httpx_client_kwargs(conf)["proxies"] == "http://127.0.0.1:8080"
diff --git a/tests/bridge/test_typing_and_comment_primitives.py b/tests/bridge/test_typing_and_comment_primitives.py
new file mode 100644
index 0000000..4b18c99
--- /dev/null
+++ b/tests/bridge/test_typing_and_comment_primitives.py
@@ -0,0 +1,404 @@
+import json
+from types import SimpleNamespace
+
+import pytest
+
+from lark_channel import CommentContext as RootCommentContext
+from lark_channel import CommentTarget as RootCommentTarget
+from lark_channel import FeishuChannel
+from lark_channel.channel.comment import CommentPrimitiveClient
+from lark_channel.channel.types import CommentContext, CommentTarget
+
+
+@pytest.mark.asyncio
+async def test_add_typing_reaction_returns_reaction_id(monkeypatch):
+    ch = FeishuChannel(app_id="cli_x", app_secret="s")
+
+    async def fake_add(message_id, emoji_type):
+        assert emoji_type == "Typing"
+        return SimpleNamespace(success=True, raw={"data": {"reaction_id": "r1"}})
+
+    monkeypatch.setattr(ch, "add_reaction", fake_add)
+    assert await ch.add_typing_reaction("om_1") == "r1"
+
+
+@pytest.mark.asyncio
+async def test_add_typing_reaction_returns_none_on_failure(monkeypatch):
+    ch = FeishuChannel(app_id="cli_x", app_secret="s")
+
+    async def fake_add(message_id, emoji_type):
+        raise RuntimeError("upstream")
+
+    monkeypatch.setattr(ch, "add_reaction", fake_add)
+    assert await ch.add_typing_reaction("om_1") is None
+
+
+@pytest.mark.asyncio
+async def test_remove_typing_reaction_best_effort(monkeypatch):
+    ch = FeishuChannel(app_id="cli_x", app_secret="s")
+
+    async def fake_remove(message_id, reaction_id):
+        raise RuntimeError("upstream")
+
+    monkeypatch.setattr(ch, "remove_reaction", fake_remove)
+    assert await ch.remove_typing_reaction("om_1", "r1") is False
+
+
+@pytest.mark.asyncio
+async def test_remove_typing_reaction_success(monkeypatch):
+    ch = FeishuChannel(app_id="cli_x", app_secret="s")
+
+    async def fake_remove(message_id, reaction_id):
+        return SimpleNamespace(success=True)
+
+    monkeypatch.setattr(ch, "remove_reaction", fake_remove)
+    assert await ch.remove_typing_reaction("om_1", "r1") is True
+
+
+def test_comment_target_rejects_unsupported_type():
+    client = CommentPrimitiveClient(raw_request=lambda req: None)
+    target = client.resolve_comment_target_sync(
+        file_token="x",
+        file_type="mindnote",
+    )
+    assert target.supported is False
+    assert target.reason == "unsupported_file_type"
+
+
+def test_comment_types_are_publicly_exported():
+    assert RootCommentContext is CommentContext
+    assert RootCommentTarget is CommentTarget
+
+
+@pytest.mark.asyncio
+async def test_reply_comment_updates_existing_thread_reply():
+    calls = []
+
+    async def raw(req):
+        calls.append((req.uri, dict(req.paths), dict(req.queries), req.body))
+        return {"code": 0, "data": {"reply_id": "r2"}}
+
+    client = CommentPrimitiveClient(raw_request=raw)
+    context = CommentContext(
+        target=CommentTarget(file_token="doc_1", file_type="docx", supported=True),
+        comment_id="c1",
+        question="q",
+        quote="",
+        is_whole=False,
+        target_reply_id="r1",
+    )
+    await client.reply_comment(context, "answer")
+
+    assert calls[0][0] == (
+        "/open-apis/drive/v1/files/:file_token/comments/:comment_id/replies/:reply_id"
+    )
+    assert calls[0][1] == {
+        "file_token": "doc_1",
+        "comment_id": "c1",
+        "reply_id": "r1",
+    }
+    assert dict(calls[0][2]) == {"file_type": "docx"}
+    assert calls[0][3] == {
+        "content": {
+            "elements": [{"type": "text_run", "text_run": {"text": "answer"}}],
+        },
+    }
+
+
+@pytest.mark.asyncio
+async def test_reply_comment_returns_none_without_reply_id_for_thread_comment():
+    async def raw(req):
+        raise AssertionError("should not call reply creation")
+
+    client = CommentPrimitiveClient(raw_request=raw)
+    context = CommentContext(
+        target=CommentTarget(file_token="doc_1", file_type="docx", supported=True),
+        comment_id="c1",
+        question="q",
+        quote="",
+        is_whole=False,
+        target_reply_id=None,
+    )
+    assert await client.reply_comment(context, "answer") is None
+
+
+@pytest.mark.asyncio
+async def test_reply_comment_creates_whole_comment():
+    calls = []
+
+    async def raw(req):
+        calls.append((req.uri, dict(req.paths), dict(req.queries), req.body))
+        return {"code": 0, "data": {"comment_id": "c2"}}
+
+    client = CommentPrimitiveClient(raw_request=raw)
+    context = CommentContext(
+        target=CommentTarget(file_token="doc_1", file_type="docx", supported=True),
+        comment_id="c1",
+        question="q",
+        quote="",
+        is_whole=True,
+        target_reply_id=None,
+    )
+
+    result = await client.reply_comment(context, "answer")
+
+    assert result["data"]["comment_id"] == "c2"
+    assert calls[0][0] == "/open-apis/drive/v1/files/:file_token/comments"
+    assert calls[0][1] == {"file_token": "doc_1"}
+    assert dict(calls[0][2]) == {"file_type": "docx"}
+    assert calls[0][3] == {
+        "reply_list": {
+            "replies": [
+                {
+                    "content": {
+                        "elements": [
+                            {"type": "text_run", "text_run": {"text": "answer"}}
+                        ],
+                    },
+                }
+            ],
+        },
+    }
+
+
+@pytest.mark.asyncio
+async def test_wiki_comment_target_resolves_to_docx():
+    async def raw(req):
+        return SimpleNamespace(
+            code=0,
+            data=SimpleNamespace(
+                node=SimpleNamespace(obj_token="doc_1", obj_type="docx")
+            ),
+        )
+
+    client = CommentPrimitiveClient(raw_request=raw)
+    target = await client.resolve_comment_target(
+        file_token="wikcn_1",
+        file_type="wiki",
+    )
+    assert target.supported is True
+    assert target.file_token == "doc_1"
+    assert target.file_type == "docx"
+
+
+@pytest.mark.asyncio
+async def test_wiki_comment_target_parses_base_response_raw_content():
+    async def raw(req):
+        return SimpleNamespace(
+            code=0,
+            raw=SimpleNamespace(
+                content=json.dumps(
+                    {
+                        "code": 0,
+                        "data": {
+                            "node": {"obj_token": "doc_1", "obj_type": "docx"}
+                        },
+                    }
+                ).encode("utf-8"),
+            ),
+        )
+
+    client = CommentPrimitiveClient(raw_request=raw)
+    target = await client.resolve_comment_target(
+        file_token="wikcn_1",
+        file_type="wiki",
+    )
+    assert target.supported is True
+    assert target.file_token == "doc_1"
+    assert target.file_type == "docx"
+
+
+@pytest.mark.asyncio
+async def test_wiki_comment_target_reports_resolution_failure():
+    async def raw(req):
+        return {
+            "code": 0,
+            "data": {"node": {"obj_token": "doc_1", "obj_type": "mindnote"}},
+        }
+
+    client = CommentPrimitiveClient(raw_request=raw)
+    target = await client.resolve_comment_target(
+        file_token="wikcn_1",
+        file_type="wiki",
+    )
+    assert target.supported is False
+    assert target.reason == "wiki_resolution_failed"
+
+
+@pytest.mark.asyncio
+async def test_comment_context_reply_id_selection_hit_miss_and_empty():
+    replies = [
+        {
+            "reply_id": "r1",
+            "content": {
+                "elements": [{"type": "text_run", "text_run": {"text": "first"}}]
+            },
+        },
+        {
+            "reply_id": "r2",
+            "content": {
+                "elements": [{"type": "text_run", "text_run": {"text": "second"}}]
+            },
+        },
+    ]
+
+    async def raw(req):
+        return {
+            "code": 0,
+            "data": {
+                "comment": {
+                    "content": {
+                        "elements": [
+                            {"type": "text_run", "text_run": {"text": "question"}}
+                        ]
+                    },
+                    "quote": {
+                        "elements": [
+                            {"type": "text_run", "text_run": {"text": "quote"}}
+                        ]
+                    },
+                    "reply_list": {"replies": replies},
+                }
+            },
+        }
+
+    client = CommentPrimitiveClient(raw_request=raw)
+    target = CommentTarget(file_token="doc_1", file_type="docx", supported=True)
+    context = await client.get_comment_context(
+        target=target,
+        comment_id="c1",
+        event_reply_id="r1",
+    )
+    assert context.target_reply_id == "r1"
+    assert context.question == "question"
+    assert context.quote == "quote"
+
+    context = await client.get_comment_context(
+        target=target,
+        comment_id="c1",
+        event_reply_id="missing",
+    )
+    assert context.target_reply_id is None
+
+    context = await client.get_comment_context(target=target, comment_id="c1")
+    assert context.target_reply_id == "r2"
+
+    async def no_replies(req):
+        return {"code": 0, "data": {"comment": {"content": "q", "reply_list": {"replies": []}}}}
+
+    client = CommentPrimitiveClient(raw_request=no_replies)
+    context = await client.get_comment_context(target=target, comment_id="c1")
+    assert context.target_reply_id is None
+
+
+@pytest.mark.asyncio
+async def test_comment_context_falls_back_to_list_on_get_failure():
+    calls = []
+
+    async def raw(req):
+        calls.append(req.uri)
+        if len(calls) == 1:
+            return {"code": 999, "msg": "missing"}
+        return {
+            "code": 0,
+            "data": {
+                "items": [
+                    {"comment_id": "other", "content": "other"},
+                    {
+                        "comment_id": "c1",
+                        "content": "q",
+                        "reply_list": {"replies": [{"reply_id": "r1"}]},
+                    },
+                ]
+            },
+        }
+
+    client = CommentPrimitiveClient(raw_request=raw)
+    target = CommentTarget(file_token="doc_1", file_type="docx", supported=True)
+    context = await client.get_comment_context(target=target, comment_id="c1")
+
+    assert calls == [
+        "/open-apis/drive/v1/files/:file_token/comments/:comment_id",
+        "/open-apis/drive/v1/files/:file_token/comments",
+    ]
+    assert context.question == "q"
+    assert context.target_reply_id == "r1"
+
+
+@pytest.mark.asyncio
+async def test_comment_context_does_not_select_unmatched_list_item():
+    async def raw(req):
+        if req.uri.endswith("/:comment_id"):
+            return {"code": 999, "msg": "missing"}
+        return {
+            "code": 0,
+            "data": {
+                "items": [
+                    {
+                        "comment_id": "other",
+                        "content": "other",
+                        "reply_list": {"replies": [{"reply_id": "r1"}]},
+                    }
+                ]
+            },
+        }
+
+    client = CommentPrimitiveClient(raw_request=raw)
+    target = CommentTarget(file_token="doc_1", file_type="docx", supported=True)
+    context = await client.get_comment_context(target=target, comment_id="c1")
+
+    assert context.comment_id == "c1"
+    assert context.question == ""
+    assert context.target_reply_id is None
+
+
+@pytest.mark.asyncio
+async def test_comment_client_fetch_and_list_are_raw_facades():
+    calls = []
+
+    async def raw(req):
+        calls.append((req.uri, dict(req.paths), dict(req.queries)))
+        return {"code": 0, "data": {"comment": {"comment_id": "c1"}}}
+
+    client = CommentPrimitiveClient(raw_request=raw)
+    target = CommentTarget(file_token="doc_1", file_type="docx", supported=True)
+
+    fetched = await client.fetch_comment(target=target, comment_id="c1")
+    listed = await client.list_comments(target=target, page_size=10)
+
+    assert fetched["data"]["comment"]["comment_id"] == "c1"
+    assert calls[0][0] == (
+        "/open-apis/drive/v1/files/:file_token/comments/:comment_id"
+    )
+    assert calls[0][1] == {"file_token": "doc_1", "comment_id": "c1"}
+    assert calls[1][0] == "/open-apis/drive/v1/files/:file_token/comments"
+    assert calls[1][1] == {"file_token": "doc_1"}
+    assert calls[1][2]["file_type"] == "docx"
+    assert calls[1][2]["page_size"] == "10"
+    assert listed["code"] == 0
+
+
+@pytest.mark.asyncio
+async def test_comment_client_list_replies_uses_confirmed_reply_endpoint():
+    calls = []
+
+    async def raw(req):
+        calls.append((req.uri, dict(req.paths), dict(req.queries)))
+        return {"code": 0, "data": {"items": [{"reply_id": "r1"}]}}
+
+    client = CommentPrimitiveClient(raw_request=raw)
+    target = CommentTarget(file_token="doc_1", file_type="docx", supported=True)
+
+    result = await client.list_comment_replies(
+        target=target,
+        comment_id="c1",
+        page_size=20,
+    )
+
+    assert result["data"]["items"][0]["reply_id"] == "r1"
+    assert calls[0][0] == (
+        "/open-apis/drive/v1/files/:file_token/comments/:comment_id/replies"
+    )
+    assert calls[0][1] == {"file_token": "doc_1", "comment_id": "c1"}
+    assert calls[0][2]["file_type"] == "docx"
+    assert calls[0][2]["page_size"] == "20"
diff --git a/tests/bridge/test_ws_proxy_keepalive.py b/tests/bridge/test_ws_proxy_keepalive.py
new file mode 100644
index 0000000..541dd66
--- /dev/null
+++ b/tests/bridge/test_ws_proxy_keepalive.py
@@ -0,0 +1,373 @@
+import asyncio
+from types import SimpleNamespace
+
+import pytest
+
+from lark_channel import FeishuChannel, TransportConfig
+from lark_channel.channel.config import KeepaliveConfig
+from lark_channel.channel.errors import FeishuChannelError
+from lark_channel.channel.keepalive import KeepaliveWatchdog
+from lark_channel.ws import client as ws_client
+
+
+def test_ws_default_keeps_current_direct_connect_behavior(monkeypatch):
+    monkeypatch.setattr(ws_client.inspect, "signature", lambda fn: type("S", (), {"parameters": {"proxy": object()}})())
+    assert ws_client._ws_connect_kwargs(proxy_url=None, trust_env_proxy=None) == {"proxy": None}
+
+
+def test_ws_explicit_proxy_wins():
+    assert ws_client._ws_connect_kwargs(
+        proxy_url="http://127.0.0.1:8080",
+        trust_env_proxy=None,
+    ) == {"proxy": "http://127.0.0.1:8080"}
+
+
+def test_ws_explicit_proxy_requires_supported_websockets(monkeypatch):
+    monkeypatch.setattr(
+        ws_client.inspect,
+        "signature",
+        lambda fn: type("S", (), {"parameters": {}})(),
+    )
+    with pytest.raises(RuntimeError, match="explicit proxy"):
+        ws_client._ws_connect_kwargs(
+            proxy_url="http://127.0.0.1:8080",
+            trust_env_proxy=None,
+        )
+
+
+def test_ws_client_default_has_no_handshake_timeout():
+    client = ws_client.Client(app_id="cli_x", app_secret="s")
+    assert client._handshake_timeout is None
+
+
+def test_ws_client_accepts_handshake_timeout():
+    client = ws_client.Client(
+        app_id="cli_x",
+        app_secret="s",
+        handshake_timeout=7.5,
+    )
+    assert client._handshake_timeout == 7.5
+
+
+def test_transport_config_positional_keepalive_compatibility():
+    keepalive = KeepaliveConfig(enabled=True)
+
+    cfg = TransportConfig("ws", True, None, 30.0, None, None, keepalive)
+
+    assert cfg.keepalive is keepalive
+    assert cfg.handshake_timeout_seconds is None
+
+
+@pytest.mark.asyncio
+async def test_ws_connect_omits_open_timeout_by_default(monkeypatch):
+    calls = {}
+
+    async def fake_connect(url, **kwargs):
+        calls["url"] = url
+        calls["kwargs"] = kwargs
+        return SimpleNamespace()
+
+    def close_task(coro):
+        coro.close()
+
+    def conn_url():
+        calls["endpoint_called"] = True
+        return "ws://example.test/callback?device_id=device&service_id=42"
+
+    client = ws_client.Client(app_id="cli_x", app_secret="s")
+    monkeypatch.setattr(client, "_get_conn_url", conn_url)
+    monkeypatch.setattr(ws_client.websockets, "connect", fake_connect)
+    monkeypatch.setattr(
+        ws_client,
+        "loop",
+        SimpleNamespace(create_task=close_task),
+    )
+
+    await client._connect()
+
+    assert calls["endpoint_called"] is True
+    assert calls["url"].startswith("ws://example.test/callback")
+    assert "open_timeout" not in calls["kwargs"]
+
+
+@pytest.mark.asyncio
+async def test_ws_connect_passes_configured_open_timeout(monkeypatch):
+    calls = {}
+
+    async def fake_connect(url, **kwargs):
+        calls["url"] = url
+        calls["kwargs"] = kwargs
+        return SimpleNamespace()
+
+    def close_task(coro):
+        coro.close()
+
+    def conn_url(*, timeout=None):
+        calls["timeout"] = timeout
+        return "ws://example.test/callback?device_id=device&service_id=42"
+
+    client = ws_client.Client(
+        app_id="cli_x",
+        app_secret="s",
+        handshake_timeout=7.5,
+    )
+    monkeypatch.setattr(client, "_get_conn_url", conn_url)
+    monkeypatch.setattr(ws_client.websockets, "connect", fake_connect)
+    monkeypatch.setattr(
+        ws_client,
+        "loop",
+        SimpleNamespace(create_task=close_task),
+    )
+
+    await client._connect()
+
+    assert calls["timeout"] == 7.5
+    assert calls["kwargs"]["open_timeout"] == 7.5
+
+
+def test_endpoint_discovery_disables_env_proxy_with_explicit_proxy(monkeypatch):
+    calls = {}
+
+    class FakeSession:
+        trust_env = True
+
+        def post(self, url, **kwargs):
+            calls["trust_env"] = self.trust_env
+            calls["url"] = url
+            calls["kwargs"] = kwargs
+            return SimpleNamespace(
+                status_code=200,
+                content=b'{"code":0,"data":{"URL":"ws://example.test/callback?device_id=device&service_id=42"}}',
+            )
+
+    monkeypatch.setattr(ws_client.requests, "Session", lambda: FakeSession())
+
+    ws_client._post_endpoint(
+        "https://open.feishu.cn/open-apis/ws/endpoint",
+        headers={"x-test": "1"},
+        body={"AppID": "cli_x", "AppSecret": "s"},
+        timeout=None,
+        proxy_url="http://127.0.0.1:8080",
+        trust_env_proxy=False,
+    )
+
+    assert calls["trust_env"] is False
+    assert calls["kwargs"]["headers"] == {"x-test": "1"}
+    assert calls["kwargs"]["json"] == {"AppID": "cli_x", "AppSecret": "s"}
+    assert calls["kwargs"]["proxies"] == {
+        "http": "http://127.0.0.1:8080",
+        "https": "http://127.0.0.1:8080",
+    }
+    assert "timeout" not in calls["kwargs"]
+
+
+@pytest.mark.asyncio
+async def test_keepalive_disabled_does_not_probe():
+    calls = []
+    watchdog = KeepaliveWatchdog(
+        config=KeepaliveConfig(enabled=False, check_interval_seconds=0.01),
+        probe=lambda: calls.append("probe") or True,
+        reconnect=lambda: calls.append("reconnect"),
+        clock=lambda: 0.0,
+    )
+    await watchdog.run_once()
+    assert calls == []
+
+
+@pytest.mark.asyncio
+async def test_keepalive_reconnects_after_wake_probe_failures():
+    times = iter([0.0, 200.0, 400.0])
+    calls = []
+    watchdog = KeepaliveWatchdog(
+        config=KeepaliveConfig(
+            enabled=True,
+            check_interval_seconds=0.01,
+            wake_threshold_seconds=90.0,
+            failure_threshold=2,
+        ),
+        probe=lambda: False,
+        reconnect=lambda: calls.append("reconnect"),
+        clock=lambda: next(times),
+    )
+    await watchdog.run_once()
+    await watchdog.run_once()
+    assert calls == ["reconnect"]
+
+
+@pytest.mark.asyncio
+async def test_ws_request_reconnect_is_serial(monkeypatch):
+    events = []
+    client = ws_client.Client(app_id="cli_x", app_secret="s")
+
+    async def fake_disconnect(**kwargs):
+        events.append("disconnect")
+
+    async def fake_reconnect_locked():
+        events.append("reconnect")
+
+    monkeypatch.setattr(client, "_disconnect", fake_disconnect)
+    monkeypatch.setattr(client, "_reconnect_locked", fake_reconnect_locked)
+    client._set_loop(asyncio.get_running_loop())
+    client.request_reconnect()
+    client.request_reconnect()
+    await asyncio.sleep(0.01)
+    assert events == ["disconnect", "reconnect"]
+
+
+@pytest.mark.asyncio
+async def test_ws_connect_returns_without_leaking_lock_when_already_connected():
+    client = ws_client.Client(app_id="cli_x", app_secret="s")
+    client._conn = object()
+
+    await client._connect()
+
+    assert not client._lock.locked()
+
+
+@pytest.mark.asyncio
+async def test_ws_reconnect_attempts_are_serial(monkeypatch):
+    client = ws_client.Client(app_id="cli_x", app_secret="s")
+    client._reconnect_nonce = 0
+    client._reconnect_count = 1
+    active = 0
+    max_active = 0
+    attempts = []
+
+    async def fake_try_connect(cnt):
+        nonlocal active, max_active
+        active += 1
+        max_active = max(max_active, active)
+        await asyncio.sleep(0.01)
+        attempts.append(cnt)
+        active -= 1
+        return True
+
+    monkeypatch.setattr(client, "_try_connect", fake_try_connect)
+
+    await asyncio.gather(client._reconnect(), client._reconnect())
+
+    assert attempts == [0, 0]
+    assert max_active == 1
+
+
+@pytest.mark.asyncio
+async def test_disconnect_wait_cancellation_does_not_release_unowned_lock():
+    client = ws_client.Client(app_id="cli_x", app_secret="s")
+    await client._lock.acquire()
+    task = asyncio.create_task(client._disconnect())
+    await asyncio.sleep(0)
+
+    task.cancel()
+    with pytest.raises(asyncio.CancelledError):
+        await task
+
+    assert client._lock.locked()
+    client._lock.release()
+
+
+@pytest.mark.asyncio
+async def test_disconnect_and_reconnect_sequence_is_serial(monkeypatch):
+    client = ws_client.Client(app_id="cli_x", app_secret="s")
+    active = 0
+    max_active = 0
+    events = []
+
+    async def guarded(label):
+        nonlocal active, max_active
+        active += 1
+        max_active = max(max_active, active)
+        events.append(f"{label}-start")
+        await asyncio.sleep(0.01)
+        events.append(f"{label}-end")
+        active -= 1
+
+    async def fake_disconnect(**kwargs):
+        await guarded("disconnect")
+
+    async def fake_reconnect_locked():
+        await guarded("reconnect")
+
+    monkeypatch.setattr(client, "_disconnect", fake_disconnect)
+    monkeypatch.setattr(client, "_reconnect_locked", fake_reconnect_locked)
+
+    await asyncio.gather(
+        client._request_reconnect_once(),
+        client._disconnect_and_reconnect(),
+    )
+
+    assert max_active == 1
+    assert events[:4] == [
+        "disconnect-start",
+        "disconnect-end",
+        "reconnect-start",
+        "reconnect-end",
+    ]
+    assert events[4:] == [
+        "disconnect-start",
+        "disconnect-end",
+        "reconnect-start",
+        "reconnect-end",
+    ]
+
+
+@pytest.mark.asyncio
+async def test_stale_receive_loop_does_not_close_new_connection(monkeypatch):
+    events = []
+    client = ws_client.Client(app_id="cli_x", app_secret="s")
+
+    class FakeConn:
+        def __init__(self, name):
+            self.name = name
+
+        async def recv(self):
+            raise RuntimeError(f"{self.name} closed")
+
+        async def close(self):
+            events.append(f"close-{self.name}")
+
+    old_conn = FakeConn("old")
+    new_conn = FakeConn("new")
+    client._conn = new_conn
+
+    async def fail_if_reconnects():
+        events.append("reconnect")
+
+    monkeypatch.setattr(client, "_reconnect_locked", fail_if_reconnects)
+
+    await client._receive_message_loop(old_conn)
+
+    assert client._conn is new_conn
+    assert events == []
+
+
+def test_channel_start_failure_cancels_keepalive(monkeypatch):
+    class FailingWS:
+        def __init__(self, *args, **kwargs):
+            self.on_reconnecting = lambda: None
+            self.on_reconnected = lambda: None
+
+        def probe_endpoint(self, *, timeout):
+            return True
+
+        def request_reconnect(self):
+            return None
+
+        def start(self):
+            raise RuntimeError("boom")
+
+    ch = FeishuChannel(
+        app_id="cli_x",
+        app_secret="s",
+        transport=TransportConfig(
+            keepalive=KeepaliveConfig(enabled=True, check_interval_seconds=10.0)
+        ),
+    )
+    monkeypatch.setattr(ch, "_fetch_bot_identity_sync", lambda: None)
+    monkeypatch.setattr("lark_channel.channel.channel.WSClient", FailingWS)
+
+    with pytest.raises(FeishuChannelError):
+        ch.start()
+
+    assert ch._keepalive_watchdog is None
+    assert ch._keepalive_future is None
+    ch.stop()
diff --git a/tests/package_identity/test_distribution_contents.py b/tests/package_identity/test_distribution_contents.py
new file mode 100644
index 0000000..6406d46
--- /dev/null
+++ b/tests/package_identity/test_distribution_contents.py
@@ -0,0 +1,74 @@
+import subprocess
+import sys
+import tarfile
+import zipfile
+from pathlib import Path
+
+import pytest
+
+
+ROOT = Path(__file__).resolve().parents[2]
+API_ALLOWLIST = ROOT / "tests" / "runtime" / "api_file_allowlist.txt"
+
+
+@pytest.fixture(scope="session")
+def built_dist(tmp_path_factory):
+    dist_dir = tmp_path_factory.mktemp("dist")
+    subprocess.run(
+        [
+            sys.executable,
+            "-m",
+            "build",
+            "--sdist",
+            "--wheel",
+            "--outdir",
+            str(dist_dir),
+            str(ROOT),
+        ],
+        check=True,
+    )
+    return dist_dir
+
+
+def _latest(dist_dir: Path, pattern: str) -> Path:
+    matches = sorted(dist_dir.glob(pattern))
+    assert matches, pattern
+    return matches[-1]
+
+
+def _contains_docs_tree(name: str) -> bool:
+    return name == "docs" or name.startswith("docs/") or "/docs/" in name or name.endswith("/docs")
+
+
+def _expected_api_files() -> set:
+    return {
+        line.strip()
+        for line in API_ALLOWLIST.read_text(encoding="utf-8").splitlines()
+        if line.strip()
+    }
+
+
+def test_built_wheel_has_lark_channel_and_no_lark_oapi(built_dist):
+    wheel = _latest(built_dist, "lark_channel_sdk-*.whl")
+    with zipfile.ZipFile(wheel) as zf:
+        names = set(zf.namelist())
+    assert any(name.startswith("lark_channel/") for name in names)
+    assert not any(name.startswith("lark_oapi/") for name in names)
+    assert not any(_contains_docs_tree(name) for name in names)
+    assert {name for name in names if name.startswith("lark_channel/api/") and name.endswith(".py")} == _expected_api_files()
+
+
+def test_built_sdist_has_lark_channel_and_no_lark_oapi(built_dist):
+    sdist = _latest(built_dist, "lark_channel_sdk-*.tar.gz")
+    with tarfile.open(sdist) as tf:
+        names = set(tf.getnames())
+    assert any("/lark_channel/" in name for name in names)
+    assert not any("/lark_oapi/" in name for name in names)
+    assert any(name.endswith("/docs/quickstart.md") for name in names)
+    assert any(name.endswith("/docs/reference.md") for name in names)
+    actual_api_files = {
+        "/".join(name.split("/")[1:])
+        for name in names
+        if "/lark_channel/api/" in name and name.endswith(".py")
+    }
+    assert actual_api_files == _expected_api_files()
diff --git a/tests/package_identity/test_documented_import_path.py b/tests/package_identity/test_documented_import_path.py
new file mode 100644
index 0000000..718b447
--- /dev/null
+++ b/tests/package_identity/test_documented_import_path.py
@@ -0,0 +1,23 @@
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[2]
+DOCS = [
+    ROOT / "README.md",
+    ROOT / "README.zh.md",
+    *(ROOT / "docs").rglob("*.md"),
+    *(ROOT / "samples").rglob("*.py"),
+    ROOT / "lark_channel" / "channel" / "__init__.py",
+    ROOT / "lark_channel" / "channel" / "channel.py",
+    ROOT / "lark_channel" / "channel" / "events.py",
+]
+
+
+def test_documented_primary_import_path_is_package_root():
+    text = "\n".join(path.read_text(encoding="utf-8") for path in DOCS if path.exists())
+    assert "from lark_channel import FeishuChannel" in text
+    assert "pip install lark-channel-sdk" in text
+    assert "pip install lark-oapi" not in text
+    assert "lark-oapi[" not in text
+    assert "from lark_channel.channel import" not in text
+    assert "from lark_oapi" not in text
diff --git a/tests/package_identity/test_import_identity.py b/tests/package_identity/test_import_identity.py
new file mode 100644
index 0000000..df554a5
--- /dev/null
+++ b/tests/package_identity/test_import_identity.py
@@ -0,0 +1,35 @@
+import importlib
+import importlib.util
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[2]
+
+
+def test_new_top_level_package_imports():
+    assert importlib.util.find_spec("lark_channel") is not None
+    mod = importlib.import_module("lark_channel")
+    assert hasattr(mod, "FeishuChannel")
+
+
+def test_target_source_tree_does_not_keep_lark_oapi_package():
+    assert not (ROOT / "lark_oapi").exists()
+
+
+def test_core_public_entrypoint_imports_from_new_path():
+    from lark_channel import FeishuChannel
+
+    assert FeishuChannel.__name__ == "FeishuChannel"
+
+
+def test_transport_keepalive_config_imports_from_package_root():
+    from lark_channel import KeepaliveConfig
+    from lark_channel.channel import KeepaliveConfig as ChannelKeepaliveConfig
+
+    assert KeepaliveConfig is ChannelKeepaliveConfig
+
+
+def test_release_version_is_1_0_0():
+    from lark_channel.core.const import VERSION
+
+    assert VERSION == "1.0.0"
diff --git a/tests/runtime/api_file_allowlist.txt b/tests/runtime/api_file_allowlist.txt
new file mode 100644
index 0000000..41b52cf
--- /dev/null
+++ b/tests/runtime/api_file_allowlist.txt
@@ -0,0 +1,247 @@
+lark_channel/api/__init__.py
+lark_channel/api/cardkit/__init__.py
+lark_channel/api/cardkit/service.py
+lark_channel/api/cardkit/v1/__init__.py
+lark_channel/api/cardkit/v1/model/__init__.py
+lark_channel/api/cardkit/v1/model/batch_update_card_request.py
+lark_channel/api/cardkit/v1/model/batch_update_card_request_body.py
+lark_channel/api/cardkit/v1/model/batch_update_card_response.py
+lark_channel/api/cardkit/v1/model/card.py
+lark_channel/api/cardkit/v1/model/content_card_element_request.py
+lark_channel/api/cardkit/v1/model/content_card_element_request_body.py
+lark_channel/api/cardkit/v1/model/content_card_element_response.py
+lark_channel/api/cardkit/v1/model/create_card_element_request.py
+lark_channel/api/cardkit/v1/model/create_card_element_request_body.py
+lark_channel/api/cardkit/v1/model/create_card_element_response.py
+lark_channel/api/cardkit/v1/model/create_card_request.py
+lark_channel/api/cardkit/v1/model/create_card_request_body.py
+lark_channel/api/cardkit/v1/model/create_card_response.py
+lark_channel/api/cardkit/v1/model/create_card_response_body.py
+lark_channel/api/cardkit/v1/model/delete_card_element_request.py
+lark_channel/api/cardkit/v1/model/delete_card_element_request_body.py
+lark_channel/api/cardkit/v1/model/delete_card_element_response.py
+lark_channel/api/cardkit/v1/model/id_convert_card_request.py
+lark_channel/api/cardkit/v1/model/id_convert_card_request_body.py
+lark_channel/api/cardkit/v1/model/id_convert_card_response.py
+lark_channel/api/cardkit/v1/model/id_convert_card_response_body.py
+lark_channel/api/cardkit/v1/model/patch_card_element_request.py
+lark_channel/api/cardkit/v1/model/patch_card_element_request_body.py
+lark_channel/api/cardkit/v1/model/patch_card_element_response.py
+lark_channel/api/cardkit/v1/model/settings_card_request.py
+lark_channel/api/cardkit/v1/model/settings_card_request_body.py
+lark_channel/api/cardkit/v1/model/settings_card_response.py
+lark_channel/api/cardkit/v1/model/update_card_element_request.py
+lark_channel/api/cardkit/v1/model/update_card_element_request_body.py
+lark_channel/api/cardkit/v1/model/update_card_element_response.py
+lark_channel/api/cardkit/v1/model/update_card_request.py
+lark_channel/api/cardkit/v1/model/update_card_request_body.py
+lark_channel/api/cardkit/v1/model/update_card_response.py
+lark_channel/api/cardkit/v1/resource/__init__.py
+lark_channel/api/cardkit/v1/resource/card.py
+lark_channel/api/cardkit/v1/resource/card_element.py
+lark_channel/api/cardkit/v1/version.py
+lark_channel/api/contact/__init__.py
+lark_channel/api/contact/service.py
+lark_channel/api/contact/v3/__init__.py
+lark_channel/api/contact/v3/model/__init__.py
+lark_channel/api/contact/v3/model/avatar_info.py
+lark_channel/api/contact/v3/model/batch_get_id_user_request.py
+lark_channel/api/contact/v3/model/batch_get_id_user_request_body.py
+lark_channel/api/contact/v3/model/batch_get_id_user_response.py
+lark_channel/api/contact/v3/model/batch_get_id_user_response_body.py
+lark_channel/api/contact/v3/model/batch_user_request.py
+lark_channel/api/contact/v3/model/batch_user_response.py
+lark_channel/api/contact/v3/model/batch_user_response_body.py
+lark_channel/api/contact/v3/model/create_user_request.py
+lark_channel/api/contact/v3/model/create_user_response.py
+lark_channel/api/contact/v3/model/create_user_response_body.py
+lark_channel/api/contact/v3/model/custom_attr_generic_user.py
+lark_channel/api/contact/v3/model/delete_user_request.py
+lark_channel/api/contact/v3/model/delete_user_request_body.py
+lark_channel/api/contact/v3/model/delete_user_response.py
+lark_channel/api/contact/v3/model/department_detail.py
+lark_channel/api/contact/v3/model/department_i18n_name.py
+lark_channel/api/contact/v3/model/department_path.py
+lark_channel/api/contact/v3/model/department_path_name.py
+lark_channel/api/contact/v3/model/find_by_department_user_request.py
+lark_channel/api/contact/v3/model/find_by_department_user_response.py
+lark_channel/api/contact/v3/model/find_by_department_user_response_body.py
+lark_channel/api/contact/v3/model/get_user_request.py
+lark_channel/api/contact/v3/model/get_user_response.py
+lark_channel/api/contact/v3/model/get_user_response_body.py
+lark_channel/api/contact/v3/model/list_user_request.py
+lark_channel/api/contact/v3/model/list_user_response.py
+lark_channel/api/contact/v3/model/list_user_response_body.py
+lark_channel/api/contact/v3/model/notification_option.py
+lark_channel/api/contact/v3/model/patch_user_request.py
+lark_channel/api/contact/v3/model/patch_user_response.py
+lark_channel/api/contact/v3/model/patch_user_response_body.py
+lark_channel/api/contact/v3/model/product_i18n_name.py
+lark_channel/api/contact/v3/model/resource_acceptor.py
+lark_channel/api/contact/v3/model/resurrect_user_request.py
+lark_channel/api/contact/v3/model/resurrect_user_request_body.py
+lark_channel/api/contact/v3/model/resurrect_user_response.py
+lark_channel/api/contact/v3/model/update_user_id_user_request.py
+lark_channel/api/contact/v3/model/update_user_id_user_request_body.py
+lark_channel/api/contact/v3/model/update_user_id_user_response.py
+lark_channel/api/contact/v3/model/update_user_request.py
+lark_channel/api/contact/v3/model/update_user_response.py
+lark_channel/api/contact/v3/model/update_user_response_body.py
+lark_channel/api/contact/v3/model/user.py
+lark_channel/api/contact/v3/model/user_assign_info.py
+lark_channel/api/contact/v3/model/user_contact_info.py
+lark_channel/api/contact/v3/model/user_custom_attr.py
+lark_channel/api/contact/v3/model/user_custom_attr_value.py
+lark_channel/api/contact/v3/model/user_department_info.py
+lark_channel/api/contact/v3/model/user_order.py
+lark_channel/api/contact/v3/model/user_position.py
+lark_channel/api/contact/v3/model/user_status.py
+lark_channel/api/contact/v3/resource/__init__.py
+lark_channel/api/contact/v3/resource/user.py
+lark_channel/api/contact/v3/version.py
+lark_channel/api/drive/__init__.py
+lark_channel/api/drive/comment.py
+lark_channel/api/im/__init__.py
+lark_channel/api/im/service.py
+lark_channel/api/im/v1/__init__.py
+lark_channel/api/im/v1/model/__init__.py
+lark_channel/api/im/v1/model/chat_change.py
+lark_channel/api/im/v1/model/chat_member_user.py
+lark_channel/api/im/v1/model/create_chat_request.py
+lark_channel/api/im/v1/model/create_chat_request_body.py
+lark_channel/api/im/v1/model/create_chat_response.py
+lark_channel/api/im/v1/model/create_chat_response_body.py
+lark_channel/api/im/v1/model/create_file_request.py
+lark_channel/api/im/v1/model/create_file_request_body.py
+lark_channel/api/im/v1/model/create_file_response.py
+lark_channel/api/im/v1/model/create_file_response_body.py
+lark_channel/api/im/v1/model/create_image_request.py
+lark_channel/api/im/v1/model/create_image_request_body.py
+lark_channel/api/im/v1/model/create_image_response.py
+lark_channel/api/im/v1/model/create_image_response_body.py
+lark_channel/api/im/v1/model/create_message_reaction_request.py
+lark_channel/api/im/v1/model/create_message_reaction_request_body.py
+lark_channel/api/im/v1/model/create_message_reaction_response.py
+lark_channel/api/im/v1/model/create_message_reaction_response_body.py
+lark_channel/api/im/v1/model/create_message_request.py
+lark_channel/api/im/v1/model/create_message_request_body.py
+lark_channel/api/im/v1/model/create_message_response.py
+lark_channel/api/im/v1/model/create_message_response_body.py
+lark_channel/api/im/v1/model/delete_chat_request.py
+lark_channel/api/im/v1/model/delete_chat_response.py
+lark_channel/api/im/v1/model/delete_message_reaction_request.py
+lark_channel/api/im/v1/model/delete_message_reaction_response.py
+lark_channel/api/im/v1/model/delete_message_reaction_response_body.py
+lark_channel/api/im/v1/model/delete_message_request.py
+lark_channel/api/im/v1/model/delete_message_response.py
+lark_channel/api/im/v1/model/emoji.py
+lark_channel/api/im/v1/model/event_message.py
+lark_channel/api/im/v1/model/event_message_reader.py
+lark_channel/api/im/v1/model/event_sender.py
+lark_channel/api/im/v1/model/follow_up.py
+lark_channel/api/im/v1/model/forward_message_request.py
+lark_channel/api/im/v1/model/forward_message_request_body.py
+lark_channel/api/im/v1/model/forward_message_response.py
+lark_channel/api/im/v1/model/forward_message_response_body.py
+lark_channel/api/im/v1/model/get_chat_request.py
+lark_channel/api/im/v1/model/get_chat_response.py
+lark_channel/api/im/v1/model/get_chat_response_body.py
+lark_channel/api/im/v1/model/get_file_request.py
+lark_channel/api/im/v1/model/get_file_response.py
+lark_channel/api/im/v1/model/get_image_request.py
+lark_channel/api/im/v1/model/get_image_response.py
+lark_channel/api/im/v1/model/get_message_request.py
+lark_channel/api/im/v1/model/get_message_resource_request.py
+lark_channel/api/im/v1/model/get_message_resource_response.py
+lark_channel/api/im/v1/model/get_message_response.py
+lark_channel/api/im/v1/model/get_message_response_body.py
+lark_channel/api/im/v1/model/i18n_content.py
+lark_channel/api/im/v1/model/i18n_names.py
+lark_channel/api/im/v1/model/link_chat_request.py
+lark_channel/api/im/v1/model/link_chat_request_body.py
+lark_channel/api/im/v1/model/link_chat_response.py
+lark_channel/api/im/v1/model/link_chat_response_body.py
+lark_channel/api/im/v1/model/list_chat.py
+lark_channel/api/im/v1/model/list_chat_request.py
+lark_channel/api/im/v1/model/list_chat_response.py
+lark_channel/api/im/v1/model/list_chat_response_body.py
+lark_channel/api/im/v1/model/list_event_moderator.py
+lark_channel/api/im/v1/model/list_message_reaction_request.py
+lark_channel/api/im/v1/model/list_message_reaction_response.py
+lark_channel/api/im/v1/model/list_message_reaction_response_body.py
+lark_channel/api/im/v1/model/list_message_request.py
+lark_channel/api/im/v1/model/list_message_response.py
+lark_channel/api/im/v1/model/list_message_response_body.py
+lark_channel/api/im/v1/model/mention.py
+lark_channel/api/im/v1/model/mention_event.py
+lark_channel/api/im/v1/model/merge_forward_message_request.py
+lark_channel/api/im/v1/model/merge_forward_message_request_body.py
+lark_channel/api/im/v1/model/merge_forward_message_response.py
+lark_channel/api/im/v1/model/merge_forward_message_response_body.py
+lark_channel/api/im/v1/model/message.py
+lark_channel/api/im/v1/model/message_body.py
+lark_channel/api/im/v1/model/message_reaction.py
+lark_channel/api/im/v1/model/moderator_list.py
+lark_channel/api/im/v1/model/operator.py
+lark_channel/api/im/v1/model/p2_im_chat_access_event_bot_p2p_chat_entered_v1.py
+lark_channel/api/im/v1/model/p2_im_chat_disbanded_v1.py
+lark_channel/api/im/v1/model/p2_im_chat_member_bot_added_v1.py
+lark_channel/api/im/v1/model/p2_im_chat_member_bot_deleted_v1.py
+lark_channel/api/im/v1/model/p2_im_chat_member_user_added_v1.py
+lark_channel/api/im/v1/model/p2_im_chat_member_user_deleted_v1.py
+lark_channel/api/im/v1/model/p2_im_chat_member_user_withdrawn_v1.py
+lark_channel/api/im/v1/model/p2_im_chat_updated_v1.py
+lark_channel/api/im/v1/model/p2_im_message_message_read_v1.py
+lark_channel/api/im/v1/model/p2_im_message_reaction_created_v1.py
+lark_channel/api/im/v1/model/p2_im_message_reaction_deleted_v1.py
+lark_channel/api/im/v1/model/p2_im_message_recalled_v1.py
+lark_channel/api/im/v1/model/p2_im_message_receive_v1.py
+lark_channel/api/im/v1/model/patch_message_request.py
+lark_channel/api/im/v1/model/patch_message_request_body.py
+lark_channel/api/im/v1/model/patch_message_response.py
+lark_channel/api/im/v1/model/push_follow_up_message_request.py
+lark_channel/api/im/v1/model/push_follow_up_message_request_body.py
+lark_channel/api/im/v1/model/push_follow_up_message_response.py
+lark_channel/api/im/v1/model/read_user.py
+lark_channel/api/im/v1/model/read_users_message_request.py
+lark_channel/api/im/v1/model/read_users_message_request_body.py
+lark_channel/api/im/v1/model/read_users_message_response.py
+lark_channel/api/im/v1/model/read_users_message_response_body.py
+lark_channel/api/im/v1/model/reply_message_request.py
+lark_channel/api/im/v1/model/reply_message_request_body.py
+lark_channel/api/im/v1/model/reply_message_response.py
+lark_channel/api/im/v1/model/reply_message_response_body.py
+lark_channel/api/im/v1/model/restricted_mode_setting.py
+lark_channel/api/im/v1/model/search_chat_request.py
+lark_channel/api/im/v1/model/search_chat_response.py
+lark_channel/api/im/v1/model/search_chat_response_body.py
+lark_channel/api/im/v1/model/sender.py
+lark_channel/api/im/v1/model/update_chat_request.py
+lark_channel/api/im/v1/model/update_chat_request_body.py
+lark_channel/api/im/v1/model/update_chat_response.py
+lark_channel/api/im/v1/model/update_message_request.py
+lark_channel/api/im/v1/model/update_message_request_body.py
+lark_channel/api/im/v1/model/update_message_response.py
+lark_channel/api/im/v1/model/update_message_response_body.py
+lark_channel/api/im/v1/model/urgent_app_message_request.py
+lark_channel/api/im/v1/model/urgent_app_message_response.py
+lark_channel/api/im/v1/model/urgent_app_message_response_body.py
+lark_channel/api/im/v1/model/urgent_phone_message_request.py
+lark_channel/api/im/v1/model/urgent_phone_message_response.py
+lark_channel/api/im/v1/model/urgent_phone_message_response_body.py
+lark_channel/api/im/v1/model/urgent_receivers.py
+lark_channel/api/im/v1/model/urgent_sms_message_request.py
+lark_channel/api/im/v1/model/urgent_sms_message_response.py
+lark_channel/api/im/v1/model/urgent_sms_message_response_body.py
+lark_channel/api/im/v1/model/user_id.py
+lark_channel/api/im/v1/processor.py
+lark_channel/api/im/v1/resource/__init__.py
+lark_channel/api/im/v1/resource/chat.py
+lark_channel/api/im/v1/resource/file.py
+lark_channel/api/im/v1/resource/image.py
+lark_channel/api/im/v1/resource/message.py
+lark_channel/api/im/v1/resource/message_reaction.py
+lark_channel/api/im/v1/resource/message_resource.py
+lark_channel/api/im/v1/version.py
+lark_channel/api/wiki/__init__.py
+lark_channel/api/wiki/node.py
diff --git a/tests/runtime/test_api_allowlist.py b/tests/runtime/test_api_allowlist.py
new file mode 100644
index 0000000..a249b49
--- /dev/null
+++ b/tests/runtime/test_api_allowlist.py
@@ -0,0 +1,123 @@
+import importlib
+import ast
+import pkgutil
+from pathlib import Path
+
+import lark_channel.api as api_root
+
+
+ROOT = Path(__file__).resolve().parents[2]
+
+ALLOWED_API_ROOTS = {"im", "contact", "cardkit", "drive", "wiki"}
+
+DIRECT_API_MODULES = {
+    "lark_channel.api.cardkit.v1.model.content_card_element_request",
+    "lark_channel.api.cardkit.v1.model.content_card_element_request_body",
+    "lark_channel.api.cardkit.v1.model.create_card_request",
+    "lark_channel.api.cardkit.v1.model.create_card_request_body",
+    "lark_channel.api.cardkit.v1.model.settings_card_request",
+    "lark_channel.api.cardkit.v1.model.settings_card_request_body",
+    "lark_channel.api.contact.v3.model.batch_user_request",
+    "lark_channel.api.drive.comment",
+    "lark_channel.api.im.v1.model.create_file_request",
+    "lark_channel.api.im.v1.model.create_file_request_body",
+    "lark_channel.api.im.v1.model.create_file_response",
+    "lark_channel.api.im.v1.model.create_file_response_body",
+    "lark_channel.api.im.v1.model.create_image_request",
+    "lark_channel.api.im.v1.model.create_image_request_body",
+    "lark_channel.api.im.v1.model.create_image_response",
+    "lark_channel.api.im.v1.model.create_image_response_body",
+    "lark_channel.api.im.v1.model.create_message_reaction_request",
+    "lark_channel.api.im.v1.model.create_message_reaction_request_body",
+    "lark_channel.api.im.v1.model.create_message_request",
+    "lark_channel.api.im.v1.model.create_message_request_body",
+    "lark_channel.api.im.v1.model.delete_message_reaction_request",
+    "lark_channel.api.im.v1.model.delete_message_request",
+    "lark_channel.api.im.v1.model.emoji",
+    "lark_channel.api.im.v1.model.forward_message_request",
+    "lark_channel.api.im.v1.model.forward_message_request_body",
+    "lark_channel.api.im.v1.model.get_chat_request",
+    "lark_channel.api.im.v1.model.get_file_request",
+    "lark_channel.api.im.v1.model.get_image_request",
+    "lark_channel.api.im.v1.model.get_message_request",
+    "lark_channel.api.im.v1.model.get_message_resource_request",
+    "lark_channel.api.im.v1.model.list_message_request",
+    "lark_channel.api.im.v1.model.p2_im_chat_member_bot_added_v1",
+    "lark_channel.api.im.v1.model.p2_im_chat_member_bot_deleted_v1",
+    "lark_channel.api.im.v1.model.p2_im_message_message_read_v1",
+    "lark_channel.api.im.v1.model.p2_im_message_reaction_created_v1",
+    "lark_channel.api.im.v1.model.p2_im_message_reaction_deleted_v1",
+    "lark_channel.api.im.v1.model.p2_im_message_receive_v1",
+    "lark_channel.api.im.v1.model.patch_message_request",
+    "lark_channel.api.im.v1.model.patch_message_request_body",
+    "lark_channel.api.im.v1.model.read_users_message_request",
+    "lark_channel.api.im.v1.model.read_users_message_request_body",
+    "lark_channel.api.im.v1.model.reply_message_request",
+    "lark_channel.api.im.v1.model.reply_message_request_body",
+    "lark_channel.api.im.v1.model.update_message_request",
+    "lark_channel.api.im.v1.model.update_message_request_body",
+    "lark_channel.api.im.v1.processor",
+    "lark_channel.api.wiki.node",
+}
+
+
+def test_api_root_contains_only_channel_allowlist():
+    roots = {m.name for m in pkgutil.iter_modules(api_root.__path__)}
+    assert roots == ALLOWED_API_ROOTS
+
+
+def test_required_direct_api_modules_import():
+    for module_name in sorted(DIRECT_API_MODULES):
+        importlib.import_module(module_name)
+
+
+def test_non_channel_api_roots_are_not_packaged():
+    api_path = Path(api_root.__file__).resolve().parent
+    for name in ("calendar", "bitable", "drive_full", "docx", "vc", "admin"):
+        assert not (api_path / name).exists(), name
+
+
+def test_full_drive_and_wiki_services_are_not_exported():
+    assert not hasattr(api_root, "DriveService")
+    assert not hasattr(api_root, "WikiService")
+
+
+def test_api_file_closure_matches_allowlist():
+    allowlist_path = ROOT / "tests/runtime/api_file_allowlist.txt"
+    expected = {
+        line.strip()
+        for line in allowlist_path.read_text(encoding="utf-8").splitlines()
+        if line.strip()
+    }
+    actual = {
+        path.relative_to(ROOT).as_posix()
+        for path in (ROOT / "lark_channel/api").rglob("*.py")
+    }
+    assert actual == expected
+
+
+def test_channel_api_imports_are_covered_by_file_allowlist():
+    expected = {
+        line.strip()
+        for line in (ROOT / "tests/runtime/api_file_allowlist.txt").read_text(encoding="utf-8").splitlines()
+        if line.strip()
+    }
+    for path in [ROOT / "lark_channel/client.py", *(ROOT / "lark_channel/channel").rglob("*.py")]:
+        current_module = ".".join(path.relative_to(ROOT).with_suffix("").parts)
+        tree = ast.parse(path.read_text(encoding="utf-8"))
+        for node in ast.walk(tree):
+            modules = []
+            if isinstance(node, ast.Import):
+                modules = [alias.name for alias in node.names]
+            elif isinstance(node, ast.ImportFrom):
+                if node.level:
+                    base = "." * node.level + (node.module or "")
+                    module = importlib.util.resolve_name(base, current_module.rsplit(".", 1)[0])
+                else:
+                    module = node.module or ""
+                modules = [module]
+            for module_name in modules:
+                if not module_name.startswith("lark_channel.api."):
+                    continue
+                rel = ROOT.joinpath(*module_name.split(".")).with_suffix(".py").relative_to(ROOT).as_posix()
+                assert rel in expected, f"{path.relative_to(ROOT)} imports {module_name}"
diff --git a/tests/runtime/test_raw_comment_requests.py b/tests/runtime/test_raw_comment_requests.py
new file mode 100644
index 0000000..23afabb
--- /dev/null
+++ b/tests/runtime/test_raw_comment_requests.py
@@ -0,0 +1,71 @@
+from lark_channel.api.drive.comment import (
+    build_comment_create_request,
+    build_comment_get_request,
+    build_comment_list_request,
+    build_comment_reply_update_request,
+)
+from lark_channel.api.wiki.node import build_wiki_node_get_request
+from lark_channel.core.enum import AccessTokenType, HttpMethod
+
+
+def test_comment_get_request_shape():
+    req = build_comment_get_request(file_token="doc_1", file_type="docx", comment_id="c1")
+    assert req.http_method == HttpMethod.GET
+    assert req.uri == "/open-apis/drive/v1/files/:file_token/comments/:comment_id"
+    assert req.paths == {"file_token": "doc_1", "comment_id": "c1"}
+    assert dict(req.queries) == {"file_type": "docx"}
+    assert req.token_types == {AccessTokenType.TENANT, AccessTokenType.USER}
+
+
+def test_comment_list_request_shape():
+    req = build_comment_list_request(file_token="doc_1", file_type="docx")
+    assert req.http_method == HttpMethod.GET
+    assert req.uri == "/open-apis/drive/v1/files/:file_token/comments"
+    assert req.paths == {"file_token": "doc_1"}
+    assert dict(req.queries) == {"file_type": "docx"}
+
+
+def test_comment_reply_update_request_shape():
+    req = build_comment_reply_update_request(
+        file_token="doc_1",
+        file_type="docx",
+        comment_id="c1",
+        reply_id="r1",
+        content="answer",
+    )
+    assert req.http_method == HttpMethod.PUT
+    assert req.uri == "/open-apis/drive/v1/files/:file_token/comments/:comment_id/replies/:reply_id"
+    assert req.paths == {"file_token": "doc_1", "comment_id": "c1", "reply_id": "r1"}
+    assert dict(req.queries) == {"file_type": "docx"}
+    assert req.body == {
+        "content": {
+            "elements": [{"type": "text_run", "text_run": {"text": "answer"}}],
+        },
+    }
+
+
+def test_comment_create_request_shape():
+    req = build_comment_create_request(file_token="doc_1", file_type="docx", content="answer")
+    assert req.http_method == HttpMethod.POST
+    assert req.uri == "/open-apis/drive/v1/files/:file_token/comments"
+    assert req.paths == {"file_token": "doc_1"}
+    assert dict(req.queries) == {"file_type": "docx"}
+    assert req.body == {
+        "reply_list": {
+            "replies": [
+                {
+                    "content": {
+                        "elements": [{"type": "text_run", "text_run": {"text": "answer"}}],
+                    },
+                }
+            ],
+        },
+    }
+
+
+def test_wiki_node_get_request_shape():
+    req = build_wiki_node_get_request(token="wikcn_x")
+    assert req.http_method == HttpMethod.GET
+    assert req.uri == "/open-apis/wiki/v2/spaces/get_node"
+    assert dict(req.queries) == {"token": "wikcn_x"}
+    assert req.token_types == {AccessTokenType.TENANT, AccessTokenType.USER}