From 0e2cd8c0188ef2d741925a117f8c4120b3622972 Mon Sep 17 00:00:00 2001
From: "Junyan Qin (Chin)" <rockchinq@gmail.com>
Date: Thu, 4 Dec 2025 13:40:38 +0800
Subject: [PATCH] Feat/kook (#1834)

* feat: add adapter file

* fix: style for bot log

* fix: kook bugs
---
 src/langbot/pkg/platform/sources/kook.png     | Bin 0 -> 14891 bytes
 src/langbot/pkg/platform/sources/kook.py      | 682 ++++++++++++++++++
 src/langbot/pkg/platform/sources/kook.yaml    |  24 +
 .../components/bot-log/view/BotLogCard.tsx    |  41 +-
 .../components/bot-log/view/botLog.module.css | 103 ++-
 5 files changed, 814 insertions(+), 36 deletions(-)
 create mode 100644 src/langbot/pkg/platform/sources/kook.png
 create mode 100644 src/langbot/pkg/platform/sources/kook.py
 create mode 100644 src/langbot/pkg/platform/sources/kook.yaml

diff --git a/src/langbot/pkg/platform/sources/kook.png b/src/langbot/pkg/platform/sources/kook.png
new file mode 100644
index 0000000000000000000000000000000000000000..ba6ea15d87bc3de9a88784202814a321141f5b64
GIT binary patch
literal 14891
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
MOkT87*dXBl0Gp*73jhEB

literal 0
HcmV?d00001

diff --git a/src/langbot/pkg/platform/sources/kook.py b/src/langbot/pkg/platform/sources/kook.py
new file mode 100644
index 00000000..2ae3196c
--- /dev/null
+++ b/src/langbot/pkg/platform/sources/kook.py
@@ -0,0 +1,682 @@
+from __future__ import annotations
+
+import typing
+import asyncio
+import json
+import base64
+import zlib
+import traceback
+import time
+
+import aiohttp
+import websockets
+import pydantic
+
+import langbot_plugin.api.definition.abstract.platform.adapter as abstract_platform_adapter
+import langbot_plugin.api.entities.builtin.platform.message as platform_message
+import langbot_plugin.api.entities.builtin.platform.events as platform_events
+import langbot_plugin.api.entities.builtin.platform.entities as platform_entities
+import langbot_plugin.api.definition.abstract.platform.event_logger as abstract_platform_logger
+
+
+class KookMessageConverter(abstract_platform_adapter.AbstractMessageConverter):
+    """Convert between LangBot MessageChain and KOOK message format"""
+
+    @staticmethod
+    async def yiri2target(message_chain: platform_message.MessageChain) -> tuple[str, int]:
+        """
+        Convert LangBot MessageChain to KOOK message format
+
+        Returns:
+            tuple: (content, message_type)
+                - content: message content string
+                - message_type: 1=text, 2=image, 4=file, 9=KMarkdown
+        """
+        content_parts = []
+        message_type = 1  # Default to text
+
+        for component in message_chain:
+            if isinstance(component, platform_message.Plain):
+                content_parts.append(component.text)
+            elif isinstance(component, platform_message.At):
+                # KOOK mention format: (met)user_id(met)
+                if component.target:
+                    content_parts.append(f'(met){component.target}(met)')
+            elif isinstance(component, platform_message.AtAll):
+                # KOOK @all format: (met)all(met)
+                content_parts.append('(met)all(met)')
+            elif isinstance(component, platform_message.Image):
+                # For images, we need to upload first via KOOK's asset API
+                # For now, we'll send the image URL if available
+                if component.url:
+                    content_parts.append(component.url)
+                    message_type = 2  # Image message type
+            elif isinstance(component, platform_message.Forward):
+                # Handle forward messages by concatenating content
+                for node in component.node_list:
+                    forward_content, _ = await KookMessageConverter.yiri2target(node.message_chain)
+                    content_parts.append(forward_content)
+            # Ignore Source and other components
+
+        content = ''.join(content_parts)
+        return content, message_type
+
+    @staticmethod
+    async def target2yiri(kook_message: dict, bot_account_id: str = '') -> platform_message.MessageChain:
+        """
+        Convert KOOK message format to LangBot MessageChain
+
+        Args:
+            kook_message: KOOK message event data dict
+            bot_account_id: Bot's account ID for handling role mentions
+        """
+        components = []
+
+        msg_type = kook_message.get('type', 1)
+        content = kook_message.get('content', '')
+        extra = kook_message.get('extra', {})
+
+        # Handle mentions
+        mentions = extra.get('mention', [])
+        mention_all = extra.get('mention_all', False)
+        mention_roles = extra.get('mention_roles', [])
+
+        if mention_all:
+            components.append(platform_message.AtAll())
+
+        for mention_id in mentions:
+            components.append(platform_message.At(target=str(mention_id)))
+
+        # Handle role mentions (when bot is mentioned via role)
+        # In KOOK, when a role that the bot has is mentioned, we receive it as a role mention
+        # We need to convert this to an At with the bot's account ID for the pipeline to recognize it
+        if mention_roles and bot_account_id:
+            # Add an At component with the bot's account ID when any role is mentioned
+            # This is because KOOK bots are often assigned roles and @role mentions should trigger responses
+            components.append(platform_message.At(target=bot_account_id))
+
+        # Strip mention patterns from content
+        # Remove user mention patterns: (met)USER_ID(met)
+        for mention_id in mentions:
+            content = content.replace(f'(met){mention_id}(met)', '')
+
+        # Remove @all pattern
+        if mention_all:
+            content = content.replace('(met)all(met)', '')
+
+        # Remove role mention patterns: (rol)ROLE_ID(rol)
+        for role_id in mention_roles:
+            content = content.replace(f'(rol){role_id}(rol)', '')
+
+        # Clean up extra whitespace
+        content = content.strip()
+
+        # Handle different message types
+        if msg_type == 1:  # Text message
+            if content:
+                components.append(platform_message.Plain(text=content))
+        elif msg_type == 2:  # Image message
+            # Image content is typically a URL
+            if content:
+                # Download image and convert to base64
+                try:
+                    async with aiohttp.ClientSession() as session:
+                        async with session.get(content) as response:
+                            if response.status == 200:
+                                image_bytes = await response.read()
+                                image_base64 = base64.b64encode(image_bytes).decode('utf-8')
+                                # Detect image format
+                                content_type = response.headers.get('Content-Type', 'image/png')
+                                components.append(
+                                    platform_message.Image(base64=f'data:{content_type};base64,{image_base64}')
+                                )
+                except Exception:
+                    # If download fails, just add as plain text
+                    components.append(platform_message.Plain(text=f'[Image: {content}]'))
+        elif msg_type == 4:  # File message
+            # For file messages, content is typically the file URL
+            attachments = extra.get('attachments', {})
+            file_name = attachments.get('name', 'file')
+            components.append(platform_message.Plain(text=f'[File: {file_name}]'))
+        elif msg_type == 9:  # KMarkdown message
+            # Note: content is already stripped of mention patterns above
+            if content:
+                components.append(platform_message.Plain(text=content))
+        elif msg_type == 10:  # Card message
+            # Card messages are complex, for now just indicate it's a card
+            components.append(platform_message.Plain(text='[Card Message]'))
+        else:
+            # Other message types, just use content as plain text
+            if content:
+                components.append(platform_message.Plain(text=content))
+
+        return platform_message.MessageChain(components)
+
+
+class KookEventConverter(abstract_platform_adapter.AbstractEventConverter):
+    """Convert between LangBot events and KOOK events"""
+
+    @staticmethod
+    async def yiri2target(event: platform_events.MessageEvent):
+        """Convert LangBot event to KOOK event (not implemented)"""
+        pass
+
+    @staticmethod
+    async def target2yiri(kook_event: dict, bot_account_id: str = '') -> platform_events.MessageEvent:
+        """
+        Convert KOOK event to LangBot MessageEvent
+
+        Args:
+            kook_event: KOOK event data dict containing channel_type, type, etc.
+            bot_account_id: Bot's account ID for handling role mentions
+
+        Returns:
+            FriendMessage or GroupMessage depending on channel_type
+        """
+        channel_type = kook_event.get('channel_type')
+        author_id = kook_event.get('author_id')
+        target_id = kook_event.get('target_id')
+        msg_timestamp = kook_event.get('msg_timestamp', int(time.time() * 1000))
+        extra = kook_event.get('extra', {})
+
+        # Convert message to MessageChain
+        message_chain = await KookMessageConverter.target2yiri(kook_event, bot_account_id)
+
+        # Convert timestamp from milliseconds to seconds
+        event_time = msg_timestamp / 1000.0
+
+        if channel_type == 'PERSON':
+            # Direct/Private message
+            author = extra.get('author', {})
+            author_name = author.get('nickname', author.get('username', str(author_id)))
+
+            return platform_events.FriendMessage(
+                sender=platform_entities.Friend(
+                    id=str(author_id),
+                    nickname=author_name,
+                    remark=str(author_id),
+                ),
+                message_chain=message_chain,
+                time=event_time,
+                source_platform_object=kook_event,
+            )
+        elif channel_type == 'GROUP':
+            # Guild/Server channel message
+            author = extra.get('author', {})
+            author_name = author.get('nickname', author.get('username', str(author_id)))
+
+            # guild_id = extra.get('guild_id', '')
+            channel_name = extra.get('channel_name', str(target_id))
+
+            return platform_events.GroupMessage(
+                sender=platform_entities.GroupMember(
+                    id=str(author_id),
+                    member_name=author_name,
+                    permission=platform_entities.Permission.Member,
+                    group=platform_entities.Group(
+                        id=str(target_id),  # Channel ID
+                        name=channel_name,
+                        permission=platform_entities.Permission.Member,
+                    ),
+                    special_title='',
+                    join_timestamp=0,
+                    last_speak_timestamp=0,
+                    mute_time_remaining=0,
+                ),
+                message_chain=message_chain,
+                time=event_time,
+                source_platform_object=kook_event,
+            )
+        else:
+            # Fallback to FriendMessage for unknown channel types
+            return platform_events.FriendMessage(
+                sender=platform_entities.Friend(
+                    id=str(author_id),
+                    nickname=str(author_id),
+                    remark=str(author_id),
+                ),
+                message_chain=message_chain,
+                time=event_time,
+                source_platform_object=kook_event,
+            )
+
+
+class KookAdapter(abstract_platform_adapter.AbstractMessagePlatformAdapter):
+    """KOOK platform adapter for LangBot"""
+
+    config: dict
+    message_converter: KookMessageConverter = KookMessageConverter()
+    event_converter: KookEventConverter = KookEventConverter()
+    listeners: typing.Dict[
+        typing.Type[platform_events.Event],
+        typing.Callable[[platform_events.Event, abstract_platform_adapter.AbstractMessagePlatformAdapter], None],
+    ] = {}
+
+    # WebSocket connection
+    ws: typing.Optional[websockets.WebSocketClientProtocol] = pydantic.Field(exclude=True, default=None)
+    ws_task: typing.Optional[asyncio.Task] = pydantic.Field(exclude=True, default=None)
+    heartbeat_task: typing.Optional[asyncio.Task] = pydantic.Field(exclude=True, default=None)
+    running: bool = pydantic.Field(exclude=True, default=False)
+
+    # Connection state
+    session_id: str = pydantic.Field(exclude=True, default='')
+    current_sn: int = pydantic.Field(exclude=True, default=0)
+    gateway_url: str = pydantic.Field(exclude=True, default='')
+
+    # HTTP session
+    http_session: typing.Optional[aiohttp.ClientSession] = pydantic.Field(exclude=True, default=None)
+
+    def __init__(self, config: dict, logger: abstract_platform_logger.AbstractEventLogger, **kwargs):
+        # Debug: Track init
+        with open('/tmp/kook_adapter_init.txt', 'w') as f:
+            f.write(f'KOOK adapter __init__ called at {time.time()}\n')
+
+        # Validate required config
+        if 'token' not in config:
+            raise Exception('KOOK adapter requires "token" in config')
+
+        super().__init__(
+            config=config,
+            logger=logger,
+            bot_account_id='',  # Will be set after connection
+            listeners={},
+            **kwargs,
+        )
+
+    async def _get_gateway_url(self) -> str:
+        """Get WebSocket gateway URL from KOOK API"""
+        base_url = 'https://www.kookapp.cn/api/v3/gateway/index'
+
+        # Always use compression for better performance
+        params = {'compress': 1}
+
+        headers = {
+            'Authorization': f'Bot {self.config["token"]}',
+        }
+
+        async with aiohttp.ClientSession() as session:
+            async with session.get(base_url, params=params, headers=headers) as response:
+                if response.status == 200:
+                    data = await response.json()
+                    if data.get('code') == 0:
+                        gateway_url = data['data']['url']
+                        return gateway_url
+                    else:
+                        raise Exception(f'Failed to get gateway URL: {data.get("message")}')
+                else:
+                    raise Exception(f'Failed to get gateway URL: HTTP {response.status}')
+
+    async def _get_bot_user_info(self) -> dict:
+        """Get bot's own user information from KOOK API"""
+        base_url = 'https://www.kookapp.cn/api/v3/user/me'
+
+        headers = {
+            'Authorization': f'Bot {self.config["token"]}',
+        }
+
+        async with aiohttp.ClientSession() as session:
+            async with session.get(base_url, headers=headers) as response:
+                if response.status == 200:
+                    data = await response.json()
+                    if data.get('code') == 0:
+                        user_info = data['data']
+                        await self.logger.info(
+                            f'Retrieved bot user info: {user_info.get("username")} (ID: {user_info.get("id")})'
+                        )
+                        return user_info
+                    else:
+                        raise Exception(f'Failed to get bot user info: {data.get("message")}')
+                else:
+                    raise Exception(f'Failed to get bot user info: HTTP {response.status}')
+
+    async def _handle_hello(self, data: dict):
+        """Handle HELLO signal (signal 1)"""
+        session_id = data.get('session_id', '')
+        self.session_id = session_id
+        await self.logger.info(f'KOOK WebSocket HELLO received, session_id: {session_id}')
+
+    async def _handle_event(self, data: dict, sn: int):
+        """Handle EVENT signal (signal 0)"""
+        self.current_sn = max(self.current_sn, sn)
+
+        # Check if this is a message event
+        event_type = data.get('type')
+        channel_type = data.get('channel_type')
+        author_id = data.get('author_id')
+
+        # Ignore messages from bot itself to prevent infinite loops
+        if self.bot_account_id and str(author_id) == self.bot_account_id:
+            await self.logger.debug(f'Ignoring message from bot itself (author_id: {author_id})')
+            return
+
+        # Only process text messages (type 1, 2, 4, 9, 10) in GROUP or PERSON channels
+        if event_type in [1, 2, 4, 9, 10] and channel_type in ['GROUP', 'PERSON']:
+            try:
+                # Convert to LangBot event
+                lb_event = await self.event_converter.target2yiri(data, self.bot_account_id)
+
+                # Call registered listener
+                event_class = type(lb_event)
+                if event_class in self.listeners:
+                    await self.listeners[event_class](lb_event, self)
+            except Exception as e:
+                await self.logger.error(f'Error handling KOOK event: {e}\n{traceback.format_exc()}')
+
+    async def _handle_pong(self, data: dict):
+        """Handle PONG signal (signal 3)"""
+        # PONG received, connection is healthy
+        pass
+
+    async def _heartbeat_loop(self):
+        """Send PING every 30 seconds"""
+        try:
+            while self.running and self.ws:
+                await asyncio.sleep(30)
+
+                if self.ws:
+                    try:
+                        ping_msg = {
+                            's': 2,  # PING signal
+                            'sn': self.current_sn,
+                        }
+                        await self.ws.send(json.dumps(ping_msg))
+                        await self.logger.debug(f'Sent PING with sn={self.current_sn}')
+                    except Exception:
+                        # Connection closed or send failed, exit loop
+                        break
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            await self.logger.error(f'Heartbeat error: {e}')
+
+    async def _websocket_loop(self):
+        """Main WebSocket event loop"""
+        retry_count = 0
+        max_retries = 3
+
+        while self.running and retry_count < max_retries:
+            try:
+                # Get gateway URL if not already retrieved
+                if not self.gateway_url:
+                    self.gateway_url = await self._get_gateway_url()
+
+                # Connect to WebSocket
+                await self.logger.info(f'Connecting to KOOK WebSocket: {self.gateway_url}')
+                async with websockets.connect(self.gateway_url) as ws:
+                    self.ws = ws
+                    await self.logger.info('KOOK WebSocket connected')
+
+                    # Start heartbeat
+                    self.heartbeat_task = asyncio.create_task(self._heartbeat_loop())
+
+                    # Wait for HELLO within 6 seconds
+                    try:
+                        hello_msg = await asyncio.wait_for(ws.recv(), timeout=6.0)
+
+                        # Handle compressed messages (same as main message loop)
+                        if isinstance(hello_msg, bytes):
+                            # Decompress if compressed
+                            try:
+                                hello_msg = zlib.decompress(hello_msg).decode('utf-8')
+                            except Exception:
+                                # Not compressed or decompression failed
+                                hello_msg = hello_msg.decode('utf-8')
+
+                        hello_data = json.loads(hello_msg)
+
+                        if hello_data.get('s') == 1:  # HELLO signal
+                            await self._handle_hello(hello_data['d'])
+                        else:
+                            raise Exception(f'Expected HELLO signal, got signal {hello_data.get("s")}')
+                    except asyncio.TimeoutError:
+                        raise Exception('Did not receive HELLO within 6 seconds')
+
+                    # Reset retry count on successful connection
+                    retry_count = 0
+
+                    # Main message loop
+                    async for message in ws:
+                        if isinstance(message, bytes):
+                            # Decompress if compressed
+                            try:
+                                message = zlib.decompress(message).decode('utf-8')
+                            except Exception:
+                                # Not compressed or decompression failed
+                                message = message.decode('utf-8')
+
+                        try:
+                            msg_data = json.loads(message)
+                            signal = msg_data.get('s')
+
+                            if signal == 0:  # EVENT
+                                data = msg_data.get('d', {})
+                                sn = msg_data.get('sn', 0)
+                                await self._handle_event(data, sn)
+                            elif signal == 3:  # PONG
+                                await self._handle_pong(msg_data.get('d', {}))
+                            elif signal == 5:  # RECONNECT
+                                await self.logger.info('Received RECONNECT signal')
+                                break  # Break to reconnect
+                            elif signal == 6:  # RESUME ACK
+                                await self.logger.info('Resume successful')
+                        except json.JSONDecodeError:
+                            await self.logger.error(f'Failed to parse message: {message}')
+                        except Exception as e:
+                            await self.logger.error(f'Error processing message: {e}\n{traceback.format_exc()}')
+
+            except websockets.exceptions.ConnectionClosed:
+                await self.logger.warning('KOOK WebSocket connection closed, reconnecting...')
+                retry_count += 1
+                await asyncio.sleep(2**retry_count)  # Exponential backoff
+            except Exception as e:
+                await self.logger.error(f'KOOK WebSocket error: {e}\n{traceback.format_exc()}')
+                retry_count += 1
+                await asyncio.sleep(2**retry_count)
+            finally:
+                # Stop heartbeat
+                if self.heartbeat_task:
+                    self.heartbeat_task.cancel()
+                    try:
+                        await self.heartbeat_task
+                    except asyncio.CancelledError:
+                        pass
+                self.ws = None
+
+        if retry_count >= max_retries:
+            await self.logger.error(f'Failed to connect after {max_retries} retries')
+
+    async def send_message(self, target_type: str, target_id: str, message: platform_message.MessageChain):
+        """Send a message to a channel or user"""
+        content, msg_type = await self.message_converter.yiri2target(message)
+
+        # Determine endpoint based on target_type
+        if target_type == 'GROUP':
+            # Send to channel
+            url = 'https://www.kookapp.cn/api/v3/message/create'
+            payload = {
+                'target_id': target_id,
+                'content': content,
+                'type': msg_type,
+            }
+        else:  # PERSON or default
+            # Send direct message
+            url = 'https://www.kookapp.cn/api/v3/direct-message/create'
+            payload = {
+                'target_id': target_id,
+                'content': content,
+                'type': msg_type,
+            }
+
+        headers = {
+            'Authorization': f'Bot {self.config["token"]}',
+            'Content-Type': 'application/json',
+        }
+
+        try:
+            if not self.http_session:
+                self.http_session = aiohttp.ClientSession()
+
+            async with self.http_session.post(url, json=payload, headers=headers) as response:
+                if response.status == 200:
+                    result = await response.json()
+                    if result.get('code') == 0:
+                        await self.logger.debug(f'Message sent successfully to {target_id}')
+                    else:
+                        await self.logger.error(f'Failed to send message: {result.get("message")}')
+                else:
+                    await self.logger.error(f'Failed to send message: HTTP {response.status}')
+        except Exception as e:
+            await self.logger.error(f'Error sending message: {e}')
+
+    async def reply_message(
+        self,
+        message_source: platform_events.MessageEvent,
+        message: platform_message.MessageChain,
+        quote_origin: bool = False,
+    ):
+        """Reply to a message"""
+        content, msg_type = await self.message_converter.yiri2target(message)
+
+        kook_event = message_source.source_platform_object
+        channel_type = kook_event.get('channel_type')
+        target_id = kook_event.get('target_id')
+        msg_id = kook_event.get('msg_id')
+
+        # Determine endpoint based on channel_type
+        if channel_type == 'GROUP':
+            url = 'https://www.kookapp.cn/api/v3/message/create'
+            payload = {
+                'target_id': target_id,
+                'content': content,
+                'type': msg_type,
+            }
+        else:  # PERSON
+            url = 'https://www.kookapp.cn/api/v3/direct-message/create'
+            # For direct messages, we need the chat_code or target_id
+            author_id = kook_event.get('author_id')
+            extra = kook_event.get('extra', {})
+            chat_code = extra.get('code', '')
+
+            payload = {
+                'content': content,
+                'type': msg_type,
+            }
+
+            if chat_code:
+                payload['chat_code'] = chat_code
+            else:
+                payload['target_id'] = str(author_id)
+
+        # Add quote if requested
+        if quote_origin and msg_id:
+            payload['quote'] = msg_id
+
+        headers = {
+            'Authorization': f'Bot {self.config["token"]}',
+            'Content-Type': 'application/json',
+        }
+
+        try:
+            if not self.http_session:
+                self.http_session = aiohttp.ClientSession()
+
+            async with self.http_session.post(url, json=payload, headers=headers) as response:
+                if response.status == 200:
+                    result = await response.json()
+                    if result.get('code') == 0:
+                        await self.logger.debug('Reply sent successfully')
+                    else:
+                        await self.logger.error(f'Failed to send reply: {result.get("message")}')
+                else:
+                    await self.logger.error(f'Failed to send reply: HTTP {response.status}')
+        except Exception as e:
+            await self.logger.error(f'Error sending reply: {e}')
+
+    async def is_muted(self, group_id: int) -> bool:
+        """Check if bot is muted in a group (not implemented for KOOK)"""
+        return False
+
+    def register_listener(
+        self,
+        event_type: typing.Type[platform_events.Event],
+        callback: typing.Callable[
+            [platform_events.Event, abstract_platform_adapter.AbstractMessagePlatformAdapter], None
+        ],
+    ):
+        """Register an event listener"""
+        self.listeners[event_type] = callback
+
+    def unregister_listener(
+        self,
+        event_type: typing.Type[platform_events.Event],
+        callback: typing.Callable[
+            [platform_events.Event, abstract_platform_adapter.AbstractMessagePlatformAdapter], None
+        ],
+    ):
+        """Unregister an event listener"""
+        self.listeners.pop(event_type, None)
+
+    async def run_async(self):
+        """Start the KOOK adapter"""
+        # Debug: Track run_async
+        with open('/tmp/kook_adapter_run.txt', 'w') as f:
+            f.write(f'KOOK adapter run_async called at {time.time()}\n')
+
+        self.running = True
+
+        try:
+            # Create HTTP session
+            self.http_session = aiohttp.ClientSession()
+
+            await self.logger.info('Starting KOOK adapter')
+
+            # Get bot's user information and set bot_account_id
+            try:
+                bot_info = await self._get_bot_user_info()
+                self.bot_account_id = str(bot_info.get('id', ''))
+            except Exception as e:
+                await self.logger.error(f'Failed to get bot user info: {e}')
+                # Continue anyway, but bot will process its own messages
+
+            # Start WebSocket connection
+            self.ws_task = asyncio.create_task(self._websocket_loop())
+
+            # Keep running
+            await self.ws_task
+        except Exception as e:
+            await self.logger.error(f'KOOK adapter error: {e}\n{traceback.format_exc()}')
+        finally:
+            self.running = False
+
+    async def kill(self) -> bool:
+        """Stop the KOOK adapter"""
+        self.running = False
+
+        # Cancel tasks
+        if self.heartbeat_task:
+            self.heartbeat_task.cancel()
+            try:
+                await self.heartbeat_task
+            except asyncio.CancelledError:
+                pass
+
+        if self.ws_task:
+            self.ws_task.cancel()
+            try:
+                await self.ws_task
+            except asyncio.CancelledError:
+                pass
+
+        # Close WebSocket
+        if self.ws:
+            try:
+                await self.ws.close()
+            except Exception:
+                pass  # Already closed or error during close
+
+        # Close HTTP session
+        if self.http_session:
+            await self.http_session.close()
+
+        await self.logger.info('KOOK adapter stopped')
+        return True
diff --git a/src/langbot/pkg/platform/sources/kook.yaml b/src/langbot/pkg/platform/sources/kook.yaml
new file mode 100644
index 00000000..c0da62c7
--- /dev/null
+++ b/src/langbot/pkg/platform/sources/kook.yaml
@@ -0,0 +1,24 @@
+apiVersion: v1
+kind: MessagePlatformAdapter
+metadata:
+  name: kook
+  label:
+    en_US: KOOK
+    zh_Hans: KOOK
+  description:
+    en_US: KOOK Adapter (formerly KaiHeiLa)
+    zh_Hans: KOOK 适配器(原开黑啦)，支持频道消息和私聊消息
+  icon: kook.png
+spec:
+  config:
+    - name: token
+      label:
+        en_US: Bot Token
+        zh_Hans: 机器人令牌
+      type: string
+      required: true
+      default: ""
+execution:
+  python:
+    path: ./kook.py
+    attr: KookAdapter
diff --git a/web/src/app/home/bots/components/bot-log/view/BotLogCard.tsx b/web/src/app/home/bots/components/bot-log/view/BotLogCard.tsx
index b7fd2e90..25be395a 100644
--- a/web/src/app/home/bots/components/bot-log/view/BotLogCard.tsx
+++ b/web/src/app/home/bots/components/bot-log/view/BotLogCard.tsx
@@ -48,7 +48,7 @@ export function BotLogCard({ botLog }: { botLog: BotLog }) {
     <div className={`${styles.botLogCardContainer}`}>
       {/* 头部标签，时间 */}
       <div className={`${styles.cardTitleContainer}`}>
-        <div className={`flex flex-row gap-4`}>
+        <div className={`flex flex-row gap-2 items-center`}>
           <div className={`${styles.tag}`}>{botLog.level}</div>
           {botLog.message_session_id && (
             <div
@@ -60,6 +60,7 @@ export function BotLogCard({ botLog }: { botLog: BotLog }) {
                     toast.success(t('common.copySuccess'));
                   });
               }}
+              title={t('common.clickToCopy')}
             >
               <svg
                 className="icon"
@@ -67,8 +68,8 @@ export function BotLogCard({ botLog }: { botLog: BotLog }) {
                 version="1.1"
                 xmlns="http://www.w3.org/2000/svg"
                 p-id="1664"
-                width="20"
-                height="20"
+                width="16"
+                height="16"
                 fill="currentColor"
               >
                 <path
@@ -87,7 +88,6 @@ export function BotLogCard({ botLog }: { botLog: BotLog }) {
                   fill="currentColor"
                 ></path>
               </svg>
-              {/* 会话ID */}
 
               <span className={`${styles.chatId}`}>
                 {getSubChatId(botLog.message_session_id)}
@@ -95,22 +95,25 @@ export function BotLogCard({ botLog }: { botLog: BotLog }) {
             </div>
           )}
         </div>
-        <div>{formatTime(botLog.timestamp)}</div>
-      </div>
-      <div className={`${styles.cardTitleContainer} ${styles.cardText}`}>
-        {botLog.text}
-      </div>
-      <PhotoProvider className={``}>
-        <div className={`w-50 mt-2`}>
-          {botLog.images.map((item) => (
-            <img
-              key={item}
-              src={`${baseURL}/api/v1/files/image/${item}`}
-              alt=""
-            />
-          ))}
+        <div className={`${styles.timestamp}`}>
+          {formatTime(botLog.timestamp)}
         </div>
-      </PhotoProvider>
+      </div>
+      <div className={`${styles.cardText}`}>{botLog.text}</div>
+      {botLog.images.length > 0 && (
+        <PhotoProvider>
+          <div className={`flex flex-wrap gap-2 mt-3`}>
+            {botLog.images.map((item) => (
+              <img
+                key={item}
+                src={`${baseURL}/api/v1/files/image/${item}`}
+                alt=""
+                className="max-w-xs rounded cursor-pointer hover:opacity-90 transition-opacity"
+              />
+            ))}
+          </div>
+        </PhotoProvider>
+      )}
     </div>
   );
 }
diff --git a/web/src/app/home/bots/components/bot-log/view/botLog.module.css b/web/src/app/home/bots/components/bot-log/view/botLog.module.css
index 9cbeffa6..ccaafbb6 100644
--- a/web/src/app/home/bots/components/bot-log/view/botLog.module.css
+++ b/web/src/app/home/bots/components/bot-log/view/botLog.module.css
@@ -1,21 +1,32 @@
 .botLogListContainer {
   width: 100%;
+  max-width: 100%;
   min-height: 10rem;
   display: flex;
   flex-direction: column;
   align-items: center;
   justify-content: flex-start;
-  overflow-y: scroll;
+  overflow-y: auto;
+  overflow-x: hidden;
+  box-sizing: border-box;
 }
 
 .botLogCardContainer {
   width: 100%;
+  max-width: 100%;
   background-color: #fff;
-  border-radius: 10px;
-  border: 1px solid #cbd5e1;
-  padding: 1.2rem;
-  margin-bottom: 1rem;
-  cursor: pointer;
+  border-radius: 8px;
+  border: 1px solid #e2e8f0;
+  padding: 1rem;
+  margin-bottom: 0.75rem;
+  transition: all 0.2s ease;
+  overflow: hidden;
+  box-sizing: border-box;
+}
+
+.botLogCardContainer:hover {
+  border-color: #cbd5e1;
+  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.05);
 }
 
 :global(.dark) .botLogCardContainer {
@@ -23,40 +34,74 @@
   border: 1px solid #2a2a2e;
 }
 
+:global(.dark) .botLogCardContainer:hover {
+  border-color: #3a3a3e;
+  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.3);
+}
+
 .listHeader {
   width: 100%;
   height: 2.5rem;
   display: flex;
   flex-direction: row;
   align-items: center;
+  margin-bottom: 0.5rem;
 }
 
 .tag {
-  display: flex;
+  display: inline-flex;
   flex-direction: row;
   align-items: center;
-  justify-content: flex-start;
-  gap: 0.2rem;
-  height: 1.5rem;
-  padding: 0.5rem;
-  border-radius: 0.4rem;
-  background-color: #a5d8ff;
-  color: #ffffff;
+  justify-content: center;
+  gap: 0.25rem;
+  height: auto;
+  padding: 0.25rem 0.5rem;
+  border-radius: 4px;
+  background-color: #dbeafe;
+  color: #1e40af;
+  font-size: 0.75rem;
+  font-weight: 500;
   max-width: 16rem;
   overflow: hidden;
   text-overflow: ellipsis;
   white-space: nowrap;
+  text-transform: uppercase;
+  letter-spacing: 0.025em;
+}
+
+:global(.dark) .tag {
+  background-color: #1e3a8a;
+  color: #93c5fd;
 }
 
 .chatTag {
-  color: #626262;
-  background-color: #d1d1d1;
+  color: #4b5563;
+  background-color: #f3f4f6;
+  text-transform: none;
+  cursor: pointer;
+  transition: all 0.15s ease;
+}
+
+.chatTag:hover {
+  background-color: #e5e7eb;
+}
+
+:global(.dark) .chatTag {
+  color: #9ca3af;
+  background-color: #374151;
+}
+
+:global(.dark) .chatTag:hover {
+  background-color: #4b5563;
 }
 
 .chatId {
   overflow: hidden;
   text-overflow: ellipsis;
   white-space: nowrap;
+  font-family: 'SF Mono', Monaco, 'Cascadia Code', 'Roboto Mono', Consolas,
+    'Courier New', monospace;
+  font-size: 0.7rem;
 }
 
 .cardTitleContainer {
@@ -65,9 +110,33 @@
   flex-direction: row;
   align-items: center;
   justify-content: space-between;
+  margin-bottom: 0.5rem;
 }
 
 .cardText {
-  margin-top: 0.4rem;
+  color: #1e293b;
+  font-size: 0.875rem;
+  line-height: 1.7;
+  white-space: pre-wrap;
+  word-wrap: break-word;
+  word-break: break-all;
+  overflow-wrap: anywhere;
+  hyphens: auto;
+  max-width: 100%;
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen',
+    'Ubuntu', 'Cantarell', sans-serif;
+}
+
+:global(.dark) .cardText {
+  color: #e2e8f0;
+}
+
+.timestamp {
+  color: #64748b;
+  font-size: 0.75rem;
+  white-space: nowrap;
+}
+
+:global(.dark) .timestamp {
   color: #64748b;
 }