feat: parallel execution of tool calls in LocalAgentRunner

Use asyncio.gather() to execute independent tool calls concurrently
instead of sequentially. LLM returns multiple tool_calls in a single
response when they are independent, so parallel execution is safe
and significantly reduces latency.

Closes #2050

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "langbot"
-version = "4.9.3"
+version = "4.9.0"
 description = "Production-grade platform for building agentic IM bots"
 readme = "README.md"
 license-files = ["LICENSE"]
@@ -64,7 +64,7 @@ dependencies = [
     "chromadb>=1.0.0,<2.0.0",
     "qdrant-client (>=1.15.1,<2.0.0)",
     "pyseekdb==1.1.0.post3",
-    "langbot-plugin==0.3.3",
+    "langbot-plugin==0.3.0",
     "asyncpg>=0.30.0",
     "line-bot-sdk>=3.19.0",
     "tboxsdk>=0.0.10",

src/langbot/__init__.py

@@ -1,3 +1,3 @@
 """LangBot - Production-grade platform for building agentic IM bots"""
 
-__version__ = '4.9.3'
+__version__ = '4.9.0'

src/langbot/libs/wecom_ai_bot_api/api.py

@@ -199,253 +199,6 @@ class StreamSessionManager:
                 self._msg_index.pop(msg_id, None)
 
 
-async def download_encrypted_file(download_url: str, encoding_aes_key: str, logger: EventLogger) -> Optional[str]:
-    """Download an AES-encrypted file from WeChat Work and return as data URI.
-
-    Args:
-        download_url: The encrypted file download URL.
-        encoding_aes_key: The AES key used for decryption (base64-encoded, without trailing '=').
-        logger: Logger instance.
-
-    Returns:
-        A data URI string (e.g. 'data:image/jpeg;base64,...') or None on failure.
-    """
-    if not download_url:
-        return None
-    async with httpx.AsyncClient() as client:
-        response = await client.get(download_url)
-        if response.status_code != 200:
-            await logger.error(f'failed to get file: {response.text}')
-            return None
-        encrypted_bytes = response.content
-
-    aes_key = base64.b64decode(encoding_aes_key + '=')
-    iv = aes_key[:16]
-
-    cipher = AES.new(aes_key, AES.MODE_CBC, iv)
-    decrypted = cipher.decrypt(encrypted_bytes)
-
-    pad_len = decrypted[-1]
-    decrypted = decrypted[:-pad_len]
-
-    if decrypted.startswith(b'\xff\xd8'):
-        mime_type = 'image/jpeg'
-    elif decrypted.startswith(b'\x89PNG'):
-        mime_type = 'image/png'
-    elif decrypted.startswith((b'GIF87a', b'GIF89a')):
-        mime_type = 'image/gif'
-    elif decrypted.startswith(b'BM'):
-        mime_type = 'image/bmp'
-    elif decrypted.startswith(b'II*\x00') or decrypted.startswith(b'MM\x00*'):
-        mime_type = 'image/tiff'
-    else:
-        mime_type = 'application/octet-stream'
-
-    base64_str = base64.b64encode(decrypted).decode('utf-8')
-    return f'data:{mime_type};base64,{base64_str}'
-
-
-async def parse_wecom_bot_message(
-    msg_json: dict[str, Any], encoding_aes_key: str, logger: EventLogger
-) -> dict[str, Any]:
-    """Parse a decrypted WeChat Work AI Bot message JSON into a unified message dict.
-
-    This is the shared message parsing logic used by both webhook and WebSocket modes.
-
-    Args:
-        msg_json: The decrypted message JSON from WeChat Work.
-        encoding_aes_key: AES key for file decryption.
-        logger: Logger instance.
-
-    Returns:
-        A dict suitable for constructing a WecomBotEvent.
-    """
-    message_data: dict[str, Any] = {}
-
-    msg_type = msg_json.get('msgtype', '')
-    if msg_type:
-        message_data['msgtype'] = msg_type
-
-    if msg_json.get('chattype', '') == 'single':
-        message_data['type'] = 'single'
-    elif msg_json.get('chattype', '') == 'group':
-        message_data['type'] = 'group'
-
-    max_inline_file_size = 5 * 1024 * 1024
-
-    async def _safe_download(url: str):
-        if not url:
-            return None
-        return await download_encrypted_file(url, encoding_aes_key, logger)
-
-    if msg_type == 'text':
-        message_data['content'] = msg_json.get('text', {}).get('content')
-    elif msg_type == 'markdown':
-        message_data['content'] = msg_json.get('markdown', {}).get('content') or msg_json.get('text', {}).get(
-            'content', ''
-        )
-    elif msg_type == 'image':
-        picurl = msg_json.get('image', {}).get('url', '')
-        base64_data = await _safe_download(picurl)
-        if base64_data:
-            message_data['picurl'] = base64_data
-            message_data['images'] = [base64_data]
-    elif msg_type == 'voice':
-        voice_info = msg_json.get('voice', {}) or {}
-        download_url = voice_info.get('url')
-        message_data['voice'] = {
-            'url': download_url,
-            'md5sum': voice_info.get('md5sum') or voice_info.get('md5'),
-            'filesize': voice_info.get('filesize') or voice_info.get('size'),
-            'sdkfileid': voice_info.get('sdkfileid') or voice_info.get('fileid'),
-        }
-        if voice_info.get('content'):
-            message_data['content'] = voice_info.get('content')
-        if (message_data['voice'].get('filesize') or 0) <= max_inline_file_size:
-            voice_base64 = await _safe_download(download_url)
-            if voice_base64:
-                message_data['voice']['base64'] = voice_base64
-    elif msg_type == 'video':
-        video_info = msg_json.get('video', {}) or {}
-        download_url = video_info.get('url')
-        video_data = {
-            'url': download_url,
-            'filesize': video_info.get('filesize') or video_info.get('size'),
-            'sdkfileid': video_info.get('sdkfileid') or video_info.get('fileid'),
-            'md5sum': video_info.get('md5sum') or video_info.get('md5'),
-            'filename': video_info.get('filename') or video_info.get('name'),
-        }
-        if (video_data.get('filesize') or 0) <= max_inline_file_size:
-            video_base64 = await _safe_download(download_url)
-            if video_base64:
-                video_data['base64'] = video_base64
-        message_data['video'] = video_data
-    elif msg_type == 'file':
-        file_info = msg_json.get('file', {}) or {}
-        download_url = file_info.get('url') or file_info.get('fileurl')
-        file_data = {
-            'filename': file_info.get('filename') or file_info.get('name'),
-            'filesize': file_info.get('filesize') or file_info.get('size'),
-            'md5sum': file_info.get('md5sum') or file_info.get('md5'),
-            'sdkfileid': file_info.get('sdkfileid') or file_info.get('fileid'),
-            'download_url': download_url,
-            'extra': file_info,
-        }
-        if (file_data.get('filesize') or 0) <= max_inline_file_size:
-            file_base64 = await _safe_download(download_url)
-            if file_base64:
-                file_data['base64'] = file_base64
-        message_data['file'] = file_data
-    elif msg_type == 'link':
-        message_data['link'] = msg_json.get('link', {})
-        if not message_data.get('content'):
-            title = message_data['link'].get('title', '')
-            desc = message_data['link'].get('description') or message_data['link'].get('digest', '')
-            message_data['content'] = '\n'.join(filter(None, [title, desc]))
-    elif msg_type == 'mixed':
-        items = msg_json.get('mixed', {}).get('msg_item', [])
-        texts = []
-        images = []
-        files = []
-        voices = []
-        videos = []
-        links = []
-        for item in items:
-            item_type = item.get('msgtype')
-            if item_type == 'text':
-                texts.append(item.get('text', {}).get('content', ''))
-            elif item_type == 'image':
-                img_url = item.get('image', {}).get('url')
-                base64_data = await _safe_download(img_url)
-                if base64_data:
-                    images.append(base64_data)
-            elif item_type == 'file':
-                file_info = item.get('file', {}) or {}
-                download_url = file_info.get('url') or file_info.get('fileurl')
-                file_data = {
-                    'filename': file_info.get('filename') or file_info.get('name'),
-                    'filesize': file_info.get('filesize') or file_info.get('size'),
-                    'md5sum': file_info.get('md5sum') or file_info.get('md5'),
-                    'sdkfileid': file_info.get('sdkfileid') or file_info.get('fileid'),
-                    'download_url': download_url,
-                    'extra': file_info,
-                }
-                if (file_data.get('filesize') or 0) <= max_inline_file_size:
-                    file_base64 = await _safe_download(download_url)
-                    if file_base64:
-                        file_data['base64'] = file_base64
-                files.append(file_data)
-            elif item_type == 'voice':
-                voice_info = item.get('voice', {}) or {}
-                download_url = voice_info.get('url')
-                voice_data = {
-                    'url': download_url,
-                    'md5sum': voice_info.get('md5sum') or voice_info.get('md5'),
-                    'filesize': voice_info.get('filesize') or voice_info.get('size'),
-                    'sdkfileid': voice_info.get('sdkfileid') or voice_info.get('fileid'),
-                }
-                if voice_info.get('content'):
-                    texts.append(voice_info.get('content'))
-                if (voice_data.get('filesize') or 0) <= max_inline_file_size:
-                    voice_base64 = await _safe_download(download_url)
-                    if voice_base64:
-                        voice_data['base64'] = voice_base64
-                voices.append(voice_data)
-            elif item_type == 'video':
-                video_info = item.get('video', {}) or {}
-                download_url = video_info.get('url')
-                video_data = {
-                    'url': download_url,
-                    'filesize': video_info.get('filesize') or video_info.get('size'),
-                    'sdkfileid': video_info.get('sdkfileid') or video_info.get('fileid'),
-                    'md5sum': video_info.get('md5sum') or video_info.get('md5'),
-                    'filename': video_info.get('filename') or video_info.get('name'),
-                }
-                if (video_data.get('filesize') or 0) <= max_inline_file_size:
-                    video_base64 = await _safe_download(download_url)
-                    if video_base64:
-                        video_data['base64'] = video_base64
-                videos.append(video_data)
-            elif item_type == 'link':
-                links.append(item.get('link', {}))
-
-        if texts:
-            message_data['content'] = ' '.join(texts)
-        if images:
-            message_data['images'] = images
-            message_data['picurl'] = images[0]
-        if files:
-            message_data['files'] = files
-            message_data['file'] = files[0]
-        if voices:
-            message_data['voices'] = voices
-            message_data['voice'] = voices[0]
-        if videos:
-            message_data['videos'] = videos
-            message_data['video'] = videos[0]
-        if links:
-            message_data['link'] = links[0]
-        if items:
-            message_data['attachments'] = items
-    else:
-        message_data['raw_msg'] = msg_json
-
-    from_info = msg_json.get('from', {})
-    message_data['userid'] = from_info.get('userid', '')
-    message_data['username'] = from_info.get('alias', '') or from_info.get('name', '') or from_info.get('userid', '')
-
-    if msg_json.get('chattype', '') == 'group':
-        message_data['chatid'] = msg_json.get('chatid', '')
-        message_data['chatname'] = msg_json.get('chatname', '') or msg_json.get('chatid', '')
-
-    message_data['msgid'] = msg_json.get('msgid', '')
-
-    if msg_json.get('aibotid'):
-        message_data['aibotid'] = msg_json.get('aibotid', '')
-
-    return message_data
-
-
 class WecomBotClient:
     def __init__(self, Token: str, EnCodingAESKey: str, Corpid: str, logger: EventLogger, unified_mode: bool = False):
         """企业微信智能机器人客户端。
@@ -702,7 +455,196 @@ class WecomBotClient:
         return await self._handle_post_initial_response(msg_json, nonce)
 
     async def get_message(self, msg_json):
-        return await parse_wecom_bot_message(msg_json, self.EnCodingAESKey, self.logger)
+        message_data = {}
+
+        msg_type = msg_json.get('msgtype', '')
+        if msg_type:
+            message_data['msgtype'] = msg_type
+
+        if msg_json.get('chattype', '') == 'single':
+            message_data['type'] = 'single'
+        elif msg_json.get('chattype', '') == 'group':
+            message_data['type'] = 'group'
+
+        max_inline_file_size = 5 * 1024 * 1024  # avoid decoding very large payloads by default
+
+        async def _safe_download(url: str):
+            if not url:
+                return None
+            return await self.download_url_to_base64(url, self.EnCodingAESKey)
+
+        if msg_type == 'text':
+            message_data['content'] = msg_json.get('text', {}).get('content')
+        elif msg_type == 'markdown':
+            message_data['content'] = msg_json.get('markdown', {}).get('content') or msg_json.get('text', {}).get(
+                'content', ''
+            )
+        elif msg_type == 'image':
+            picurl = msg_json.get('image', {}).get('url', '')
+            base64_data = await _safe_download(picurl)
+            if base64_data:
+                message_data['picurl'] = base64_data
+                message_data['images'] = [base64_data]
+        elif msg_type == 'voice':
+            voice_info = msg_json.get('voice', {}) or {}
+            download_url = voice_info.get('url')
+            message_data['voice'] = {
+                'url': download_url,
+                'md5sum': voice_info.get('md5sum') or voice_info.get('md5'),
+                'filesize': voice_info.get('filesize') or voice_info.get('size'),
+                'sdkfileid': voice_info.get('sdkfileid') or voice_info.get('fileid'),
+            }
+            # 企业微信智能转写文本（如果已有）直接复用，避免重复转写
+            if voice_info.get('content'):
+                message_data['content'] = voice_info.get('content')
+            if (message_data['voice'].get('filesize') or 0) <= max_inline_file_size:
+                voice_base64 = await _safe_download(download_url)
+                if voice_base64:
+                    message_data['voice']['base64'] = voice_base64
+        elif msg_type == 'video':
+            video_info = msg_json.get('video', {}) or {}
+            download_url = video_info.get('url')
+            video_data = {
+                'url': download_url,
+                'filesize': video_info.get('filesize') or video_info.get('size'),
+                'sdkfileid': video_info.get('sdkfileid') or video_info.get('fileid'),
+                'md5sum': video_info.get('md5sum') or video_info.get('md5'),
+                'filename': video_info.get('filename') or video_info.get('name'),
+            }
+            if (video_data.get('filesize') or 0) <= max_inline_file_size:
+                video_base64 = await _safe_download(download_url)
+                if video_base64:
+                    video_data['base64'] = video_base64
+            message_data['video'] = video_data
+        elif msg_type == 'file':
+            file_info = msg_json.get('file', {}) or {}
+            download_url = file_info.get('url') or file_info.get('fileurl')
+            file_data = {
+                'filename': file_info.get('filename') or file_info.get('name'),
+                'filesize': file_info.get('filesize') or file_info.get('size'),
+                'md5sum': file_info.get('md5sum') or file_info.get('md5'),
+                'sdkfileid': file_info.get('sdkfileid') or file_info.get('fileid'),
+                'download_url': download_url,
+                'extra': file_info,
+            }
+            if (file_data.get('filesize') or 0) <= max_inline_file_size:
+                file_base64 = await _safe_download(download_url)
+                if file_base64:
+                    file_data['base64'] = file_base64
+            message_data['file'] = file_data
+        elif msg_type == 'link':
+            message_data['link'] = msg_json.get('link', {})
+            if not message_data.get('content'):
+                title = message_data['link'].get('title', '')
+                desc = message_data['link'].get('description') or message_data['link'].get('digest', '')
+                message_data['content'] = '\n'.join(filter(None, [title, desc]))
+        elif msg_type == 'mixed':
+            items = msg_json.get('mixed', {}).get('msg_item', [])
+            texts = []
+            images = []
+            files = []
+            voices = []
+            videos = []
+            links = []
+            for item in items:
+                item_type = item.get('msgtype')
+                if item_type == 'text':
+                    texts.append(item.get('text', {}).get('content', ''))
+                elif item_type == 'image':
+                    img_url = item.get('image', {}).get('url')
+                    base64_data = await _safe_download(img_url)
+                    if base64_data:
+                        images.append(base64_data)
+                elif item_type == 'file':
+                    file_info = item.get('file', {}) or {}
+                    download_url = file_info.get('url') or file_info.get('fileurl')
+                    file_data = {
+                        'filename': file_info.get('filename') or file_info.get('name'),
+                        'filesize': file_info.get('filesize') or file_info.get('size'),
+                        'md5sum': file_info.get('md5sum') or file_info.get('md5'),
+                        'sdkfileid': file_info.get('sdkfileid') or file_info.get('fileid'),
+                        'download_url': download_url,
+                        'extra': file_info,
+                    }
+                    if (file_data.get('filesize') or 0) <= max_inline_file_size:
+                        file_base64 = await _safe_download(download_url)
+                        if file_base64:
+                            file_data['base64'] = file_base64
+                    files.append(file_data)
+                elif item_type == 'voice':
+                    voice_info = item.get('voice', {}) or {}
+                    download_url = voice_info.get('url')
+                    voice_data = {
+                        'url': download_url,
+                        'md5sum': voice_info.get('md5sum') or voice_info.get('md5'),
+                        'filesize': voice_info.get('filesize') or voice_info.get('size'),
+                        'sdkfileid': voice_info.get('sdkfileid') or voice_info.get('fileid'),
+                    }
+                    if voice_info.get('content'):
+                        texts.append(voice_info.get('content'))
+                    if (voice_data.get('filesize') or 0) <= max_inline_file_size:
+                        voice_base64 = await _safe_download(download_url)
+                        if voice_base64:
+                            voice_data['base64'] = voice_base64
+                    voices.append(voice_data)
+                elif item_type == 'video':
+                    video_info = item.get('video', {}) or {}
+                    download_url = video_info.get('url')
+                    video_data = {
+                        'url': download_url,
+                        'filesize': video_info.get('filesize') or video_info.get('size'),
+                        'sdkfileid': video_info.get('sdkfileid') or video_info.get('fileid'),
+                        'md5sum': video_info.get('md5sum') or video_info.get('md5'),
+                        'filename': video_info.get('filename') or video_info.get('name'),
+                    }
+                    if (video_data.get('filesize') or 0) <= max_inline_file_size:
+                        video_base64 = await _safe_download(download_url)
+                        if video_base64:
+                            video_data['base64'] = video_base64
+                    videos.append(video_data)
+                elif item_type == 'link':
+                    links.append(item.get('link', {}))
+
+            if texts:
+                message_data['content'] = ' '.join(texts)  # 拼接所有 text
+            if images:
+                message_data['images'] = images
+                message_data['picurl'] = images[0]  # 只保留第一个 image
+            if files:
+                message_data['files'] = files
+                message_data['file'] = files[0]
+            if voices:
+                message_data['voices'] = voices
+                message_data['voice'] = voices[0]
+            if videos:
+                message_data['videos'] = videos
+                message_data['video'] = videos[0]
+            if links:
+                message_data['link'] = links[0]
+            if items:
+                message_data['attachments'] = items
+        else:
+            message_data['raw_msg'] = msg_json
+
+        # Extract user information
+        from_info = msg_json.get('from', {})
+        message_data['userid'] = from_info.get('userid', '')
+        message_data['username'] = (
+            from_info.get('alias', '') or from_info.get('name', '') or from_info.get('userid', '')
+        )
+
+        # Extract chat/group information
+        if msg_json.get('chattype', '') == 'group':
+            message_data['chatid'] = msg_json.get('chatid', '')
+            # Try to get group name if available
+            message_data['chatname'] = msg_json.get('chatname', '') or msg_json.get('chatid', '')
+
+        message_data['msgid'] = msg_json.get('msgid', '')
+
+        if msg_json.get('aibotid'):
+            message_data['aibotid'] = msg_json.get('aibotid', '')
+
+        return message_data
 
     async def _handle_message(self, event: wecombotevent.WecomBotEvent):
         """
@@ -770,7 +712,39 @@ class WecomBotClient:
         return decorator
 
     async def download_url_to_base64(self, download_url, encoding_aes_key):
-        return await download_encrypted_file(download_url, encoding_aes_key, self.logger)
+        async with httpx.AsyncClient() as client:
+            response = await client.get(download_url)
+            if response.status_code != 200:
+                await self.logger.error(f'failed to get file: {response.text}')
+                return None
+
+            encrypted_bytes = response.content
+
+        aes_key = base64.b64decode(encoding_aes_key + '=')  # base64 补齐
+        iv = aes_key[:16]
+
+        cipher = AES.new(aes_key, AES.MODE_CBC, iv)
+        decrypted = cipher.decrypt(encrypted_bytes)
+
+        pad_len = decrypted[-1]
+        decrypted = decrypted[:-pad_len]
+
+        if decrypted.startswith(b'\xff\xd8'):  # JPEG
+            mime_type = 'image/jpeg'
+        elif decrypted.startswith(b'\x89PNG'):  # PNG
+            mime_type = 'image/png'
+        elif decrypted.startswith((b'GIF87a', b'GIF89a')):  # GIF
+            mime_type = 'image/gif'
+        elif decrypted.startswith(b'BM'):  # BMP
+            mime_type = 'image/bmp'
+        elif decrypted.startswith(b'II*\x00') or decrypted.startswith(b'MM\x00*'):  # TIFF
+            mime_type = 'image/tiff'
+        else:
+            mime_type = 'application/octet-stream'
+
+        # 转 base64
+        base64_str = base64.b64encode(decrypted).decode('utf-8')
+        return f'data:{mime_type};base64,{base64_str}'
 
     async def run_task(self, host: str, port: int, *args, **kwargs):
         """

src/langbot/libs/wecom_ai_bot_api/ws_client.py

@@ -1,596 +0,0 @@
-"""WeChat Work AI Bot WebSocket long connection client.
-
-Implements the WebSocket protocol for receiving messages and sending replies
-via a persistent connection to wss://openws.work.weixin.qq.com, as an
-alternative to the HTTP callback (webhook) mode.
-
-Protocol reference: https://developer.work.weixin.qq.com/document/path/101463
-Official Node.js SDK: https://github.com/WecomTeam/aibot-node-sdk
-"""
-
-from __future__ import annotations
-
-import asyncio
-import json
-import secrets
-import time
-import traceback
-from typing import Any, Callable, Optional
-
-import aiohttp
-
-from langbot.libs.wecom_ai_bot_api import wecombotevent
-from langbot.libs.wecom_ai_bot_api.api import parse_wecom_bot_message
-from langbot.pkg.platform.logger import EventLogger
-
-DEFAULT_WS_URL = 'wss://openws.work.weixin.qq.com'
-
-# WebSocket frame command constants
-CMD_SUBSCRIBE = 'aibot_subscribe'
-CMD_HEARTBEAT = 'ping'
-CMD_MSG_CALLBACK = 'aibot_msg_callback'
-CMD_EVENT_CALLBACK = 'aibot_event_callback'
-CMD_RESPOND_MSG = 'aibot_respond_msg'
-CMD_RESPOND_WELCOME = 'aibot_respond_welcome_msg'
-CMD_RESPOND_UPDATE = 'aibot_respond_update_msg'
-CMD_SEND_MSG = 'aibot_send_msg'
-
-
-def _generate_req_id(prefix: str) -> str:
-    """Generate a unique request ID in the format: {prefix}_{timestamp}_{random}."""
-    ts = int(time.time() * 1000)
-    rand = secrets.token_hex(4)
-    return f'{prefix}_{ts}_{rand}'
-
-
-class WecomBotWsClient:
-    """WeChat Work AI Bot WebSocket long connection client.
-
-    Provides message receiving, streaming reply, proactive message sending,
-    and event callback handling over a persistent WebSocket connection.
-    """
-
-    def __init__(
-        self,
-        bot_id: str,
-        secret: str,
-        logger: EventLogger,
-        encoding_aes_key: str = '',
-        ws_url: str = DEFAULT_WS_URL,
-        heartbeat_interval: float = 30.0,
-        max_reconnect_attempts: int = -1,
-        reconnect_base_delay: float = 1.0,
-        reconnect_max_delay: float = 30.0,
-    ):
-        self.bot_id = bot_id
-        self.secret = secret
-        self.logger = logger
-        self.encoding_aes_key = encoding_aes_key
-        self.ws_url = ws_url
-        self.heartbeat_interval = heartbeat_interval
-        self.max_reconnect_attempts = max_reconnect_attempts
-        self.reconnect_base_delay = reconnect_base_delay
-        self.reconnect_max_delay = reconnect_max_delay
-
-        self._ws: Optional[aiohttp.ClientWebSocketResponse] = None
-        self._session: Optional[aiohttp.ClientSession] = None
-        self._running = False
-        self._heartbeat_task: Optional[asyncio.Task] = None
-        self._missed_pong_count = 0
-        self._max_missed_pong = 2
-        self._reconnect_attempts = 0
-
-        # Message handler registry (same pattern as WecomBotClient)
-        self._message_handlers: dict[str, list[Callable]] = {}
-        # Message deduplication
-        self._msg_id_map: dict[str, int] = {}
-
-        # Pending ACK futures: req_id -> Future[dict]
-        self._pending_acks: dict[str, asyncio.Future] = {}
-        # Per-req_id serial reply queues
-        self._reply_queues: dict[str, asyncio.Queue] = {}
-        self._reply_workers: dict[str, asyncio.Task] = {}
-        self._reply_ack_timeout = 5.0
-
-        # Stream ID tracking for WebSocket mode
-        self._stream_ids: dict[str, str] = {}  # msg_id -> req_id|stream_id
-        # Dedup: skip sending when content hasn't changed
-        self._stream_last_content: dict[str, str] = {}  # msg_id -> last content sent
-
-    # ── Public API ──────────────────────────────────────────────────
-
-    async def connect(self):
-        """Connect to WebSocket server with automatic reconnection.
-
-        This method blocks until disconnect() is called or max reconnect
-        attempts are exhausted.
-        """
-        self._running = True
-        self._reconnect_attempts = 0
-
-        while self._running:
-            try:
-                await self._connect_once()
-            except Exception:
-                if not self._running:
-                    break
-                await self.logger.error(f'WebSocket connection error: {traceback.format_exc()}')
-
-            if not self._running:
-                break
-
-            # Reconnect with exponential backoff
-            if self.max_reconnect_attempts != -1 and self._reconnect_attempts >= self.max_reconnect_attempts:
-                await self.logger.error(f'Max reconnect attempts reached ({self.max_reconnect_attempts}), giving up')
-                break
-
-            self._reconnect_attempts += 1
-            delay = min(
-                self.reconnect_base_delay * (2 ** (self._reconnect_attempts - 1)),
-                self.reconnect_max_delay,
-            )
-            await self.logger.info(f'Reconnecting in {delay:.1f}s (attempt {self._reconnect_attempts})...')
-            await asyncio.sleep(delay)
-
-    async def disconnect(self):
-        """Gracefully disconnect from the WebSocket server."""
-        self._running = False
-        if self._heartbeat_task and not self._heartbeat_task.done():
-            self._heartbeat_task.cancel()
-        for task in self._reply_workers.values():
-            if not task.done():
-                task.cancel()
-        if self._ws and not self._ws.closed:
-            await self._ws.close()
-        self._ws = None
-        if self._session and not self._session.closed:
-            await self._session.close()
-        self._session = None
-
-    def on_message(self, msg_type: str) -> Callable:
-        """Decorator to register a message handler.
-
-        Same interface as WecomBotClient.on_message for compatibility.
-
-        Args:
-            msg_type: 'single', 'group', or specific message type.
-        """
-
-        def decorator(func: Callable[[wecombotevent.WecomBotEvent], Any]):
-            if msg_type not in self._message_handlers:
-                self._message_handlers[msg_type] = []
-            self._message_handlers[msg_type].append(func)
-            return func
-
-        return decorator
-
-    async def reply_stream(
-        self,
-        req_id: str,
-        stream_id: str,
-        content: str,
-        finish: bool = False,
-    ) -> Optional[dict]:
-        """Send a streaming reply frame.
-
-        Args:
-            req_id: The req_id from the original message frame (must be passed through).
-            stream_id: The stream ID for this streaming session.
-            content: The content to send (supports Markdown).
-            finish: Whether this is the final chunk.
-
-        Returns:
-            The ACK frame dict, or None on failure.
-        """
-        body = {
-            'msgtype': 'stream',
-            'stream': {
-                'id': stream_id,
-                'finish': finish,
-                'content': content,
-            },
-        }
-        return await self._send_reply(req_id, body)
-
-    async def reply_text(self, req_id: str, content: str) -> Optional[dict]:
-        """Send a non-streaming text reply.
-
-        Args:
-            req_id: The req_id from the original message frame.
-            content: The text content to reply.
-
-        Returns:
-            The ACK frame dict, or None on failure.
-        """
-        body = {
-            'msgtype': 'markdown',
-            'markdown': {
-                'content': content,
-            },
-        }
-        return await self._send_reply(req_id, body)
-
-    async def send_message(self, chat_id: str, content: str, msgtype: str = 'markdown') -> Optional[dict]:
-        """Proactively send a message to a specified chat.
-
-        Args:
-            chat_id: The chat ID (userid for single chat, chatid for group chat).
-            content: The message content.
-            msgtype: Message type, 'markdown' by default.
-
-        Returns:
-            The ACK frame dict, or None on failure.
-        """
-        req_id = _generate_req_id(CMD_SEND_MSG)
-        body: dict[str, Any] = {
-            'chatid': chat_id,
-            'msgtype': msgtype,
-        }
-        if msgtype == 'markdown':
-            body['markdown'] = {'content': content}
-        elif msgtype == 'text':
-            body['text'] = {'content': content}
-        return await self._send_reply(req_id, body, cmd=CMD_SEND_MSG)
-
-    async def push_stream_chunk(self, msg_id: str, content: str, is_final: bool = False) -> bool:
-        """Push a streaming chunk for a given message ID.
-
-        Compatible interface with WecomBotClient.push_stream_chunk.
-
-        Args:
-            msg_id: The original message ID.
-            content: The cumulative content from the pipeline.
-            is_final: Whether this is the final chunk.
-
-        Returns:
-            True if the stream session exists and chunk was sent.
-        """
-        key = self._stream_ids.get(msg_id)
-        if not key:
-            return False
-        req_id, stream_id = key.split('|', 1)
-        try:
-            # Skip sending if content hasn't changed (e.g. during tool call argument streaming)
-            if not is_final and content == self._stream_last_content.get(msg_id):
-                return True
-            await self.reply_stream(req_id, stream_id, content, finish=is_final)
-            self._stream_last_content[msg_id] = content
-            if is_final:
-                self._stream_ids.pop(msg_id, None)
-                self._stream_last_content.pop(msg_id, None)
-            return True
-        except Exception:
-            await self.logger.error(f'Failed to push stream chunk: {traceback.format_exc()}')
-            return False
-
-    async def set_message(self, msg_id: str, content: str):
-        """Fallback: send content as a final stream chunk or direct reply.
-
-        Compatible interface with WecomBotClient.set_message.
-        """
-        handled = await self.push_stream_chunk(msg_id, content, is_final=True)
-        if not handled:
-            await self.logger.warning(f'No active stream for msg_id={msg_id}, message dropped')
-
-    # ── Connection lifecycle ────────────────────────────────────────
-
-    async def _connect_once(self):
-        """Establish a single WebSocket connection, authenticate, and listen."""
-        await self.logger.info(f'Connecting to {self.ws_url}...')
-
-        self._session = aiohttp.ClientSession()
-        try:
-            self._ws = await self._session.ws_connect(self.ws_url)
-            self._missed_pong_count = 0
-            self._reconnect_attempts = 0
-            await self.logger.info('WebSocket connected, sending auth...')
-
-            await self._send_auth()
-
-            # Wait for auth response
-            auth_ok = await self._wait_for_auth()
-            if not auth_ok:
-                await self.logger.error('Authentication failed')
-                return
-
-            await self.logger.info('Authenticated successfully')
-
-            # Start heartbeat
-            self._heartbeat_task = asyncio.create_task(self._heartbeat_loop())
-
-            try:
-                await self._listen_loop()
-            finally:
-                if self._heartbeat_task and not self._heartbeat_task.done():
-                    self._heartbeat_task.cancel()
-                self._clear_pending_acks('Connection closed')
-        finally:
-            if self._ws and not self._ws.closed:
-                await self._ws.close()
-            self._ws = None
-            if self._session and not self._session.closed:
-                await self._session.close()
-            self._session = None
-
-    async def _send_auth(self):
-        """Send the authentication frame."""
-        frame = {
-            'cmd': CMD_SUBSCRIBE,
-            'headers': {'req_id': _generate_req_id(CMD_SUBSCRIBE)},
-            'body': {
-                'bot_id': self.bot_id,
-                'secret': self.secret,
-            },
-        }
-        await self._send_frame(frame)
-
-    async def _wait_for_auth(self) -> bool:
-        """Wait for and validate the authentication response."""
-        try:
-            msg = await asyncio.wait_for(self._ws.receive(), timeout=10.0)
-            if msg.type in (aiohttp.WSMsgType.TEXT,):
-                frame = json.loads(msg.data)
-                req_id = frame.get('headers', {}).get('req_id', '')
-                if req_id.startswith(CMD_SUBSCRIBE) and frame.get('errcode') == 0:
-                    return True
-                await self.logger.error(f'Auth response: errcode={frame.get("errcode")}, errmsg={frame.get("errmsg")}')
-                return False
-            elif msg.type in (aiohttp.WSMsgType.ERROR, aiohttp.WSMsgType.CLOSED, aiohttp.WSMsgType.CLOSING):
-                await self.logger.error(f'WebSocket closed during auth: {msg.type}')
-                return False
-            await self.logger.error(f'Unexpected message type during auth: {msg.type}')
-            return False
-        except asyncio.TimeoutError:
-            await self.logger.error('Auth response timeout')
-            return False
-
-    async def _heartbeat_loop(self):
-        """Periodically send heartbeat pings."""
-        try:
-            while self._running and self._ws and not self._ws.closed:
-                await asyncio.sleep(self.heartbeat_interval)
-                if not self._running or not self._ws or self._ws.closed:
-                    break
-
-                if self._missed_pong_count >= self._max_missed_pong:
-                    await self.logger.warning(
-                        f'No heartbeat ack for {self._missed_pong_count} consecutive pings, connection considered dead'
-                    )
-                    await self._ws.close()
-                    break
-
-                self._missed_pong_count += 1
-                frame = {
-                    'cmd': CMD_HEARTBEAT,
-                    'headers': {'req_id': _generate_req_id(CMD_HEARTBEAT)},
-                }
-                try:
-                    await self._send_frame(frame)
-                except Exception:
-                    break
-        except asyncio.CancelledError:
-            pass
-
-    async def _listen_loop(self):
-        """Listen for incoming WebSocket frames and dispatch them."""
-        async for msg in self._ws:
-            if not self._running:
-                break
-            if msg.type == aiohttp.WSMsgType.TEXT:
-                try:
-                    frame = json.loads(msg.data)
-                    await self._handle_frame(frame)
-                except json.JSONDecodeError:
-                    await self.logger.error(f'Failed to parse WebSocket message: {str(msg.data)[:200]}')
-                except Exception:
-                    await self.logger.error(f'Error handling frame: {traceback.format_exc()}')
-            elif msg.type == aiohttp.WSMsgType.BINARY:
-                try:
-                    frame = json.loads(msg.data)
-                    await self._handle_frame(frame)
-                except Exception:
-                    await self.logger.error(f'Error handling binary frame: {traceback.format_exc()}')
-            elif msg.type in (aiohttp.WSMsgType.ERROR, aiohttp.WSMsgType.CLOSED, aiohttp.WSMsgType.CLOSING):
-                await self.logger.warning(f'WebSocket connection closed: {msg.type}')
-                break
-
-    # ── Frame handling ──────────────────────────────────────────────
-
-    async def _handle_frame(self, frame: dict):
-        """Route an incoming frame to the appropriate handler."""
-        cmd = frame.get('cmd', '')
-
-        # Message push
-        if cmd == CMD_MSG_CALLBACK:
-            asyncio.create_task(self._handle_message_callback(frame))
-            return
-
-        # Event push
-        if cmd == CMD_EVENT_CALLBACK:
-            asyncio.create_task(self._handle_event_callback(frame))
-            return
-
-        # No cmd → response/ACK frame, dispatch by req_id prefix
-        req_id = frame.get('headers', {}).get('req_id', '')
-
-        # Check pending ACKs first
-        if req_id in self._pending_acks:
-            future = self._pending_acks.pop(req_id)
-            if not future.done():
-                future.set_result(frame)
-            return
-
-        # Heartbeat response
-        if req_id.startswith(CMD_HEARTBEAT):
-            if frame.get('errcode') == 0:
-                self._missed_pong_count = 0
-            return
-
-        # Unknown frame
-        await self.logger.warning(f'Unknown frame: {json.dumps(frame, ensure_ascii=False)[:200]}')
-
-    async def _handle_message_callback(self, frame: dict):
-        """Handle an incoming message callback frame."""
-        try:
-            body = frame.get('body', {})
-            req_id = frame.get('headers', {}).get('req_id', '')
-
-            # Parse message using shared logic
-            message_data = await parse_wecom_bot_message(body, self.encoding_aes_key, self.logger)
-            if not message_data:
-                return
-
-            # Generate stream_id for this message and store the mapping
-            stream_id = _generate_req_id('stream')
-            msg_id = message_data.get('msgid', '')
-            if msg_id:
-                self._stream_ids[msg_id] = f'{req_id}|{stream_id}'
-            message_data['stream_id'] = stream_id
-            message_data['req_id'] = req_id
-
-            event = wecombotevent.WecomBotEvent(message_data)
-            await self._dispatch_event(event)
-        except Exception:
-            await self.logger.error(f'Error in message callback: {traceback.format_exc()}')
-
-    async def _handle_event_callback(self, frame: dict):
-        """Handle an incoming event callback frame (enter_chat, template_card_event, etc.)."""
-        try:
-            body = frame.get('body', {})
-            req_id = frame.get('headers', {}).get('req_id', '')
-
-            event_info = body.get('event', {})
-            event_type = event_info.get('eventtype', '')
-
-            message_data = {
-                'msgtype': 'event',
-                'type': body.get('chattype', 'single'),
-                'event': event_info,
-                'eventtype': event_type,
-                'msgid': body.get('msgid', ''),
-                'aibotid': body.get('aibotid', ''),
-                'req_id': req_id,
-            }
-
-            from_info = body.get('from', {})
-            message_data['userid'] = from_info.get('userid', '')
-            message_data['username'] = from_info.get('alias', '') or from_info.get('userid', '')
-
-            if body.get('chatid'):
-                message_data['chatid'] = body.get('chatid', '')
-
-            event = wecombotevent.WecomBotEvent(message_data)
-
-            # Dispatch to event-specific handlers
-            if event_type in self._message_handlers:
-                for handler in self._message_handlers[event_type]:
-                    await handler(event)
-
-            # Also dispatch to generic 'event' handlers
-            if 'event' in self._message_handlers:
-                for handler in self._message_handlers['event']:
-                    await handler(event)
-
-        except Exception:
-            await self.logger.error(f'Error in event callback: {traceback.format_exc()}')
-
-    async def _dispatch_event(self, event: wecombotevent.WecomBotEvent):
-        """Dispatch a message event to registered handlers with deduplication."""
-        try:
-            message_id = event.message_id
-            if message_id in self._msg_id_map:
-                self._msg_id_map[message_id] += 1
-                return
-            self._msg_id_map[message_id] = 1
-
-            msg_type = event.type
-            if msg_type in self._message_handlers:
-                for handler in self._message_handlers[msg_type]:
-                    await handler(event)
-        except Exception:
-            await self.logger.error(f'Error dispatching event: {traceback.format_exc()}')
-
-    # ── Reply sending with serial queue ─────────────────────────────
-
-    async def _send_reply(
-        self,
-        req_id: str,
-        body: dict,
-        cmd: str = CMD_RESPOND_MSG,
-    ) -> Optional[dict]:
-        """Send a reply frame and wait for ACK.
-
-        Replies with the same req_id are serialized to maintain ordering.
-        """
-        if not self._ws or self._ws.closed:
-            return None
-
-        frame = {
-            'cmd': cmd,
-            'headers': {'req_id': req_id},
-            'body': body,
-        }
-
-        # Ensure serial delivery per req_id
-        if req_id not in self._reply_queues:
-            self._reply_queues[req_id] = asyncio.Queue()
-            self._reply_workers[req_id] = asyncio.create_task(self._reply_queue_worker(req_id))
-
-        future: asyncio.Future = asyncio.get_event_loop().create_future()
-        await self._reply_queues[req_id].put((frame, future))
-        return await future
-
-    async def _reply_queue_worker(self, req_id: str):
-        """Process reply queue items serially for a given req_id."""
-        queue = self._reply_queues[req_id]
-        try:
-            while self._running:
-                try:
-                    frame, future = await asyncio.wait_for(queue.get(), timeout=60.0)
-                except asyncio.TimeoutError:
-                    # Queue idle, clean up worker
-                    break
-
-                try:
-                    ack = await self._send_and_wait_ack(frame)
-                    if not future.done():
-                        future.set_result(ack)
-                except Exception as e:
-                    if not future.done():
-                        future.set_exception(e)
-        except asyncio.CancelledError:
-            pass
-        finally:
-            self._reply_queues.pop(req_id, None)
-            self._reply_workers.pop(req_id, None)
-
-    async def _send_and_wait_ack(self, frame: dict) -> Optional[dict]:
-        """Send a frame and wait for the corresponding ACK."""
-        req_id = frame['headers']['req_id']
-        ack_future: asyncio.Future = asyncio.get_event_loop().create_future()
-        self._pending_acks[req_id] = ack_future
-
-        try:
-            await self._send_frame(frame)
-            result = await asyncio.wait_for(ack_future, timeout=self._reply_ack_timeout)
-            if result.get('errcode', 0) != 0:
-                await self.logger.warning(
-                    f'Reply ACK error: errcode={result.get("errcode")}, errmsg={result.get("errmsg")}'
-                )
-            return result
-        except asyncio.TimeoutError:
-            self._pending_acks.pop(req_id, None)
-            await self.logger.warning(f'Reply ACK timeout ({self._reply_ack_timeout}s) for req_id={req_id}')
-            return None
-
-    async def _send_frame(self, frame: dict):
-        """Send a JSON frame over the WebSocket connection."""
-        if self._ws and not self._ws.closed:
-            await self._ws.send_str(json.dumps(frame, ensure_ascii=False))
-
-    def _clear_pending_acks(self, reason: str):
-        """Reject all pending ACK futures on disconnection."""
-        for req_id, future in self._pending_acks.items():
-            if not future.done():
-                future.set_exception(ConnectionError(reason))
-        self._pending_acks.clear()

src/langbot/pkg/api/http/service/bot.py

@@ -68,20 +68,14 @@ class BotService:
             'wecomcs',
             'LINE',
             'lark',
-            'gewechat',
         ]:
             webhook_prefix = self.ap.instance_config.data['api'].get('webhook_prefix', 'http://127.0.0.1:5300')
-            extra_webhook_prefix = self.ap.instance_config.data['api'].get('extra_webhook_prefix', '')
             webhook_url = f'/bots/{bot_uuid}'
             adapter_runtime_values['webhook_url'] = webhook_url
             adapter_runtime_values['webhook_full_url'] = f'{webhook_prefix}{webhook_url}'
-            adapter_runtime_values['extra_webhook_full_url'] = (
-                f'{extra_webhook_prefix}{webhook_url}' if extra_webhook_prefix else ''
-            )
         else:
             adapter_runtime_values['webhook_url'] = None
             adapter_runtime_values['webhook_full_url'] = None
-            adapter_runtime_values['extra_webhook_full_url'] = None
 
         persistence_bot['adapter_runtime_values'] = adapter_runtime_values
 

src/langbot/pkg/api/http/service/model.py

@@ -105,16 +105,11 @@ class LLMModelsService:
                 )
             )
             pipeline = result.first()
-            if pipeline is not None:
-                model_config = pipeline.config.get('ai', {}).get('local-agent', {}).get('model', {})
-                if not model_config.get('primary', ''):
-                    pipeline_config = pipeline.config
-                    pipeline_config['ai']['local-agent']['model'] = {
-                        'primary': model_data['uuid'],
-                        'fallbacks': [],
-                    }
-                    pipeline_data = {'config': pipeline_config}
-                    await self.ap.pipeline_service.update_pipeline(pipeline.uuid, pipeline_data)
+            if pipeline is not None and pipeline.config['ai']['local-agent']['model'] == '':
+                pipeline_config = pipeline.config
+                pipeline_config['ai']['local-agent']['model'] = model_data['uuid']
+                pipeline_data = {'config': pipeline_config}
+                await self.ap.pipeline_service.update_pipeline(pipeline.uuid, pipeline_data)
 
         return model_data['uuid']
 

src/langbot/pkg/core/stages/load_config.py

@@ -74,26 +74,20 @@ def _apply_env_overrides_to_config(cfg: dict) -> dict:
         current = cfg
 
         for i, key in enumerate(keys):
-            if not isinstance(current, dict):
+            if not isinstance(current, dict) or key not in current:
                 break
 
             if i == len(keys) - 1:
-                # At the final key
-                if key in current:
-                    if isinstance(current[key], (dict, list)):
-                        # Skip dict and list types
-                        pass
-                    else:
-                        # Valid scalar value - convert and set it
-                        converted_value = convert_value(env_value, current[key])
-                        current[key] = converted_value
+                # At the final key - check if it's a scalar value
+                if isinstance(current[key], (dict, list)):
+                    # Skip dict and list types
+                    pass
                 else:
-                    # Key doesn't exist yet - create it as string
-                    current[key] = env_value
+                    # Valid scalar value - convert and set it
+                    converted_value = convert_value(env_value, current[key])
+                    current[key] = converted_value
             else:
-                # Navigate deeper - create intermediate dict if needed
-                if key not in current:
-                    current[key] = {}
+                # Navigate deeper
                 current = current[key]
 
     return cfg
@@ -152,50 +146,16 @@ class LoadConfigStage(stage.BootingStage):
         await ap.instance_config.dump_config()
 
         # load or generate instance id
-        # Priority:
-        # 1. system.instance_id from config.yaml (can be set via SYSTEM__INSTANCE_ID env var)
-        # 2. data/labels/instance_id.json (if file exists)
-        # 3. Generate new and save to file
-        config_instance_id = ap.instance_config.data.get('system', {}).get('instance_id', '')
+        ap.instance_id = await config.load_json_config(
+            'data/labels/instance_id.json',
+            template_data={
+                'instance_id': f'instance_{str(uuid.uuid4())}',
+                'instance_create_ts': int(time.time()),
+            },
+            completion=False,
+        )
 
-        if config_instance_id:
-            # Use the instance_id from config.yaml
-            constants.instance_id = config_instance_id
-            # Still load/create the file for backward compat, but don't use its value
-            ap.instance_id = await config.load_json_config(
-                'data/labels/instance_id.json',
-                template_data={
-                    'instance_id': f'instance_{str(uuid.uuid4())}',
-                    'instance_create_ts': int(time.time()),
-                },
-                completion=False,
-            )
-        else:
-            # Try loading file-based instance id
-            instance_id_path = os.path.join('data', 'labels', 'instance_id.json')
-            if os.path.exists(instance_id_path):
-                # File exists, read it
-                ap.instance_id = await config.load_json_config(
-                    'data/labels/instance_id.json',
-                    template_data={
-                        'instance_id': '',
-                        'instance_create_ts': 0,
-                    },
-                    completion=False,
-                )
-                constants.instance_id = ap.instance_id.data['instance_id']
-            else:
-                # Neither config nor file, generate new and save to file
-                new_id = f'instance_{str(uuid.uuid4())}'
-                ap.instance_id = await config.load_json_config(
-                    'data/labels/instance_id.json',
-                    template_data={
-                        'instance_id': new_id,
-                        'instance_create_ts': int(time.time()),
-                    },
-                    completion=False,
-                )
-                constants.instance_id = new_id
+        constants.instance_id = ap.instance_id.data['instance_id']
         constants.edition = ap.instance_config.data.get('system', {}).get('edition', 'community')
 
         print(f'LangBot instance id: {constants.instance_id}')

src/langbot/pkg/persistence/migrations/dbm024_wecombot_websocket_mode.py

@@ -1,49 +0,0 @@
-from .. import migration
-
-import sqlalchemy
-import json
-
-
-@migration.migration_class(24)
-class DBMigrateWecomBotWebSocketMode(migration.DBMigration):
-    """Add enable-webhook field to existing wecombot adapter configs.
-
-    Existing wecombot bots were all using webhook mode, so we set
-    enable-webhook=true to preserve their behavior after the new
-    WebSocket long connection mode is introduced as default.
-    """
-
-    async def upgrade(self):
-        """Upgrade"""
-        result = await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.text("SELECT uuid, adapter_config FROM bots WHERE adapter = 'wecombot'")
-        )
-        bots = result.fetchall()
-
-        for bot_row in bots:
-            bot_uuid = bot_row[0]
-            adapter_config = json.loads(bot_row[1]) if isinstance(bot_row[1], str) else bot_row[1]
-
-            if 'enable-webhook' in adapter_config:
-                continue
-
-            # Determine mode based on existing config: if webhook fields are present, keep webhook mode
-            has_webhook_config = bool(
-                adapter_config.get('Token') and adapter_config.get('EncodingAESKey') and adapter_config.get('Corpid')
-            )
-            adapter_config['enable-webhook'] = has_webhook_config
-
-            if self.ap.persistence_mgr.db.name == 'postgresql':
-                await self.ap.persistence_mgr.execute_async(
-                    sqlalchemy.text('UPDATE bots SET adapter_config = :config::jsonb WHERE uuid = :uuid'),
-                    {'config': json.dumps(adapter_config), 'uuid': bot_uuid},
-                )
-            else:
-                await self.ap.persistence_mgr.execute_async(
-                    sqlalchemy.text('UPDATE bots SET adapter_config = :config WHERE uuid = :uuid'),
-                    {'config': json.dumps(adapter_config), 'uuid': bot_uuid},
-                )
-
-    async def downgrade(self):
-        """Downgrade"""
-        pass

src/langbot/pkg/pipeline/preproc/preproc.py

@@ -176,16 +176,6 @@ class PreProcessor(stage.PipelineStage):
         query.variables['user_message_text'] = plain_text
 
         query.user_message = provider_message.Message(role='user', content=content_list)
-
-        # Extract knowledge base UUIDs into query variables so plugins can modify them
-        # during PromptPreProcessing before the runner performs retrieval.
-        kb_uuids = query.pipeline_config['ai']['local-agent'].get('knowledge-bases', [])
-        if not kb_uuids:
-            old_kb_uuid = query.pipeline_config['ai']['local-agent'].get('knowledge-base', '')
-            if old_kb_uuid and old_kb_uuid != '__none__':
-                kb_uuids = [old_kb_uuid]
-        query.variables['_knowledge_base_uuids'] = list(kb_uuids)
-
         # =========== 触发事件 PromptPreProcessing
 
         event = events.PromptPreProcessing(

src/langbot/pkg/platform/botmgr.py

@@ -272,9 +272,6 @@ class PlatformManager:
         # 如果 adapter 支持 set_bot_uuid 方法，设置 bot_uuid（用于统一 webhook）
         if hasattr(adapter_inst, 'set_bot_uuid'):
             adapter_inst.set_bot_uuid(bot_entity.uuid)
-            adapter_inst.config['_webhook_prefix'] = self.ap.instance_config.data['api'].get(
-                'webhook_prefix', 'http://127.0.0.1:5300'
-            )
 
         runtime_bot = RuntimeBot(ap=self.ap, bot_entity=bot_entity, adapter=adapter_inst, logger=logger)
 

src/langbot/pkg/platform/sources/gewechat.py

@@ -1,609 +0,0 @@
-import gewechat_client
-
-import typing
-import asyncio
-import traceback
-
-import re
-import copy
-import threading
-
-from langbot.pkg.utils import httpclient
-
-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
-from ...utils import image
-import xml.etree.ElementTree as ET
-from typing import Optional, Tuple
-from functools import partial
-from ..logger import EventLogger
-
-
-class GewechatMessageConverter(abstract_platform_adapter.AbstractMessageConverter):
-    def __init__(self, config: dict):
-        self.config = config
-
-    @staticmethod
-    async def yiri2target(message_chain: platform_message.MessageChain) -> list[dict]:
-        content_list = []
-        for component in message_chain:
-            if isinstance(component, platform_message.At):
-                content_list.append({'type': 'at', 'target': component.target})
-            elif isinstance(component, platform_message.Plain):
-                content_list.append({'type': 'text', 'content': component.text})
-            elif isinstance(component, platform_message.Image):
-                if not component.url:
-                    pass
-                content_list.append({'type': 'image', 'image': component.url})
-            elif isinstance(component, platform_message.Voice):
-                content_list.append({'type': 'voice', 'url': component.url, 'length': component.length})
-            elif isinstance(component, platform_message.Forward):
-                for node in component.node_list:
-                    content_list.extend(await GewechatMessageConverter.yiri2target(node.message_chain))
-                content_list.append({'type': 'image', 'image': component.url})
-            elif isinstance(component, platform_message.WeChatMiniPrograms):
-                content_list.append(
-                    {
-                        'type': 'WeChatMiniPrograms',
-                        'mini_app_id': component.mini_app_id,
-                        'display_name': component.display_name,
-                        'page_path': component.page_path,
-                        'cover_img_url': component.image_url,
-                        'title': component.title,
-                        'user_name': component.user_name,
-                    }
-                )
-            elif isinstance(component, platform_message.WeChatForwardMiniPrograms):
-                content_list.append(
-                    {
-                        'type': 'WeChatForwardMiniPrograms',
-                        'xml_data': component.xml_data,
-                        'image_url': component.image_url,
-                    }
-                )
-            elif isinstance(component, platform_message.WeChatEmoji):
-                content_list.append(
-                    {
-                        'type': 'WeChatEmoji',
-                        'emoji_md5': component.emoji_md5,
-                        'emoji_size': component.emoji_size,
-                    }
-                )
-            elif isinstance(component, platform_message.WeChatLink):
-                content_list.append(
-                    {
-                        'type': 'WeChatLink',
-                        'link_title': component.link_title,
-                        'link_desc': component.link_desc,
-                        'link_thumb_url': component.link_thumb_url,
-                        'link_url': component.link_url,
-                    }
-                )
-            elif isinstance(component, platform_message.WeChatForwardLink):
-                content_list.append({'type': 'WeChatForwardLink', 'xml_data': component.xml_data})
-            elif isinstance(component, platform_message.WeChatForwardImage):
-                content_list.append({'type': 'WeChatForwardImage', 'xml_data': component.xml_data})
-            elif isinstance(component, platform_message.WeChatForwardFile):
-                content_list.append({'type': 'WeChatForwardFile', 'xml_data': component.xml_data})
-            elif isinstance(component, platform_message.WeChatAppMsg):
-                content_list.append({'type': 'WeChatAppMsg', 'app_msg': component.app_msg})
-            elif isinstance(component, platform_message.WeChatForwardQuote):
-                content_list.append({'type': 'WeChatAppMsg', 'app_msg': component.app_msg})
-            elif isinstance(component, platform_message.Forward):
-                for node in component.node_list:
-                    if node.message_chain:
-                        content_list.extend(await GewechatMessageConverter.yiri2target(node.message_chain))
-
-        return content_list
-
-    async def target2yiri(self, message: dict, bot_account_id: str) -> platform_message.MessageChain:
-        message_list = []
-        ats_bot = False
-        content = message['Data']['Content']['string']
-        content_no_preifx = content
-        is_group_message = self._is_group_message(message)
-        if is_group_message:
-            ats_bot = self._ats_bot(message, bot_account_id)
-            if '@所有人' in content:
-                message_list.append(platform_message.AtAll())
-            elif ats_bot:
-                message_list.append(platform_message.At(target=bot_account_id))
-            content_no_preifx, _ = self._extract_content_and_sender(content)
-
-        msg_type = message['Data']['MsgType']
-
-        handler_map = {
-            1: self._handler_text,
-            3: self._handler_image,
-            34: self._handler_voice,
-            49: self._handler_compound,
-        }
-
-        handler = handler_map.get(msg_type, self._handler_default)
-        handler_result = await handler(
-            message=message,
-            content_no_preifx=content_no_preifx,
-        )
-
-        if handler_result and len(handler_result) > 0:
-            message_list.extend(handler_result)
-
-        return platform_message.MessageChain(message_list)
-
-    async def _handler_text(self, message: Optional[dict], content_no_preifx: str) -> platform_message.MessageChain:
-        if message and self._is_group_message(message):
-            pattern = r'@\S{1,20}'
-            content_no_preifx = re.sub(pattern, '', content_no_preifx)
-
-        return platform_message.MessageChain([platform_message.Plain(content_no_preifx)])
-
-    async def _handler_image(self, message: Optional[dict], content_no_preifx: str) -> platform_message.MessageChain:
-        try:
-            image_xml = content_no_preifx
-            if not image_xml:
-                return platform_message.MessageChain([platform_message.Unknown('[图片内容为空]')])
-
-            base64_str, image_format = await image.get_gewechat_image_base64(
-                gewechat_url=self.config['gewechat_url'],
-                gewechat_file_url=self.config['gewechat_file_url'],
-                app_id=self.config['app_id'],
-                xml_content=image_xml,
-                token=self.config['token'],
-                image_type=2,
-            )
-
-            elements = [
-                platform_message.Image(base64=f'data:image/{image_format};base64,{base64_str}'),
-                platform_message.WeChatForwardImage(xml_data=image_xml),
-            ]
-            return platform_message.MessageChain(elements)
-        except Exception as e:
-            print(f'处理图片失败: {str(e)}')
-            return platform_message.MessageChain([platform_message.Unknown('[图片处理失败]')])
-
-    async def _handler_voice(self, message: Optional[dict], content_no_preifx: str) -> platform_message.MessageChain:
-        message_List = []
-        try:
-            audio_base64 = message['Data']['ImgBuf']['buffer']
-
-            if not audio_base64:
-                message_List.append(platform_message.Unknown(text='[语音内容为空]'))
-                return platform_message.MessageChain(message_List)
-
-            voice_element = platform_message.Voice(base64=f'data:audio/silk;base64,{audio_base64}')
-            message_List.append(voice_element)
-
-        except KeyError as e:
-            print(f'语音数据字段缺失: {str(e)}')
-            message_List.append(platform_message.Unknown(text='[语音数据解析失败]'))
-        except Exception as e:
-            print(f'处理语音消息异常: {str(e)}')
-            message_List.append(platform_message.Unknown(text='[语音处理失败]'))
-
-        return platform_message.MessageChain(message_List)
-
-    async def _handler_compound(self, message: Optional[dict], content_no_preifx: str) -> platform_message.MessageChain:
-        try:
-            xml_data = ET.fromstring(content_no_preifx)
-            appmsg_data = xml_data.find('.//appmsg')
-            if appmsg_data:
-                data_type = appmsg_data.findtext('.//type', '')
-
-                sub_handler_map = {
-                    '57': self._handler_compound_quote,
-                    '5': self._handler_compound_link,
-                    '6': self._handler_compound_file,
-                    '33': self._handler_compound_mini_program,
-                    '36': self._handler_compound_mini_program,
-                    '2000': partial(self._handler_compound_unsupported, text='[转账消息]'),
-                    '2001': partial(self._handler_compound_unsupported, text='[红包消息]'),
-                    '51': partial(self._handler_compound_unsupported, text='[视频号消息]'),
-                }
-
-                handler = sub_handler_map.get(data_type, self._handler_compound_unsupported)
-                return await handler(
-                    message=message,
-                    xml_data=xml_data,
-                )
-            else:
-                return platform_message.MessageChain([platform_message.Unknown(text=content_no_preifx)])
-        except Exception as e:
-            print(f'解析复合消息失败: {str(e)}')
-            return platform_message.MessageChain([platform_message.Unknown(text=content_no_preifx)])
-
-    async def _handler_compound_quote(
-        self, message: Optional[dict], xml_data: ET.Element
-    ) -> platform_message.MessageChain:
-        message_list = []
-        appmsg_data = xml_data.find('.//appmsg')
-        quote_data = ''
-        user_data = ''
-        sender_id = xml_data.findtext('.//fromusername')
-        if appmsg_data:
-            user_data = appmsg_data.findtext('.//title') or ''
-            quote_data = appmsg_data.find('.//refermsg').findtext('.//content')
-            message_list.append(
-                platform_message.WeChatForwardQuote(app_msg=ET.tostring(appmsg_data, encoding='unicode'))
-            )
-        if quote_data:
-            quote_data_message_list = platform_message.MessageChain()
-            try:
-                if '<msg>' not in quote_data:
-                    quote_data_message_list.append(platform_message.Plain(quote_data))
-                else:
-                    quote_data_xml = ET.fromstring(quote_data)
-                    if quote_data_xml.find('img'):
-                        quote_data_message_list.extend(await self._handler_image(None, quote_data))
-                    elif quote_data_xml.find('voicemsg'):
-                        quote_data_message_list.extend(await self._handler_voice(None, quote_data))
-                    elif quote_data_xml.find('videomsg'):
-                        quote_data_message_list.extend(await self._handler_default(None, quote_data))
-                    else:
-                        quote_data_message_list.extend(await self._handler_compound(None, quote_data))
-            except Exception as e:
-                print(f'处理引用消息异常 expcetion:{e}')
-                quote_data_message_list.append(platform_message.Plain(quote_data))
-            message_list.append(
-                platform_message.Quote(
-                    sender_id=sender_id,
-                    origin=quote_data_message_list,
-                )
-            )
-            if len(user_data) > 0:
-                pattern = r'@\S{1,20}'
-                user_data = re.sub(pattern, '', user_data)
-                message_list.append(platform_message.Plain(user_data))
-
-        return platform_message.MessageChain(message_list)
-
-    async def _handler_compound_file(self, message: dict, xml_data: ET.Element) -> platform_message.MessageChain:
-        xml_data_str = ET.tostring(xml_data, encoding='unicode')
-        return platform_message.MessageChain([platform_message.WeChatForwardFile(xml_data=xml_data_str)])
-
-    async def _handler_compound_link(self, message: dict, xml_data: ET.Element) -> platform_message.MessageChain:
-        message_list = []
-        try:
-            appmsg = xml_data.find('.//appmsg')
-            if appmsg is None:
-                return platform_message.MessageChain()
-            message_list.append(
-                platform_message.WeChatLink(
-                    link_title=appmsg.findtext('title', ''),
-                    link_desc=appmsg.findtext('des', ''),
-                    link_url=appmsg.findtext('url', ''),
-                    link_thumb_url=appmsg.findtext('thumburl', ''),
-                )
-            )
-            xml_data_str = ET.tostring(xml_data, encoding='unicode')
-            message_list.append(platform_message.WeChatForwardLink(xml_data=xml_data_str))
-        except Exception as e:
-            print(f'解析链接消息失败: {str(e)}')
-        return platform_message.MessageChain(message_list)
-
-    async def _handler_compound_mini_program(
-        self, message: dict, xml_data: ET.Element
-    ) -> platform_message.MessageChain:
-        xml_data_str = ET.tostring(xml_data, encoding='unicode')
-        return platform_message.MessageChain([platform_message.WeChatForwardMiniPrograms(xml_data=xml_data_str)])
-
-    async def _handler_default(self, message: Optional[dict], content_no_preifx: str) -> platform_message.MessageChain:
-        if message:
-            msg_type = message['Data']['MsgType']
-        else:
-            msg_type = ''
-        return platform_message.MessageChain([platform_message.Unknown(text=f'[未知消息类型 msg_type:{msg_type}]')])
-
-    def _handler_compound_unsupported(
-        self, message: dict, xml_data: str, text: Optional[str] = None
-    ) -> platform_message.MessageChain:
-        if not text:
-            text = f'[xml_data={xml_data}]'
-        content_list = []
-        content_list.append(platform_message.Unknown(text=f'[处理未支持复合消息类型[msg_type=49]|{text}'))
-
-        return platform_message.MessageChain(content_list)
-
-    def _ats_bot(self, message: dict, bot_account_id: str) -> bool:
-        ats_bot = False
-        try:
-            to_user_name = message['Wxid']
-            raw_content = message['Data']['Content']['string']
-            content_no_prefix, _ = self._extract_content_and_sender(raw_content)
-            push_content = message.get('Data', {}).get('PushContent', '')
-            ats_bot = ats_bot or ('在群聊中@了你' in push_content)
-            msg_source = message.get('Data', {}).get('MsgSource', '') or ''
-            if len(msg_source) > 0:
-                msg_source_data = ET.fromstring(msg_source)
-                at_user_list = msg_source_data.findtext('atuserlist') or ''
-                ats_bot = ats_bot or (to_user_name in at_user_list)
-            if message.get('Data', {}).get('MsgType', 0) == 49:
-                xml_data = ET.fromstring(content_no_prefix)
-                appmsg_data = xml_data.find('.//appmsg')
-                tousername = message['Wxid']
-                if appmsg_data:
-                    quote_id = appmsg_data.find('.//refermsg').findtext('.//chatusr')
-                    ats_bot = ats_bot or (quote_id == tousername)
-        except Exception as e:
-            print(f'Error in gewechat _ats_bot: {e}')
-        finally:
-            return ats_bot
-
-    def _extract_content_and_sender(self, raw_content: str) -> Tuple[str, Optional[str]]:
-        try:
-            regex = re.compile(r'^[a-zA-Z0-9_\-]{5,20}:')
-            line_split = raw_content.split('\n')
-            if len(line_split) > 0 and regex.match(line_split[0]):
-                raw_content = '\n'.join(line_split[1:])
-                sender_id = line_split[0].strip(':')
-                return raw_content, sender_id
-        except Exception as e:
-            print(f'_extract_content_and_sender got except: {e}')
-        finally:
-            return raw_content, None
-
-    def _is_group_message(self, message: dict) -> bool:
-        from_user_name = message['Data']['FromUserName']['string']
-        return from_user_name.endswith('@chatroom')
-
-
-class GewechatEventConverter(abstract_platform_adapter.AbstractEventConverter):
-    def __init__(self, config: dict):
-        self.config = config
-        self.message_converter = GewechatMessageConverter(config)
-
-    @staticmethod
-    async def yiri2target(event: platform_events.MessageEvent) -> dict:
-        pass
-
-    async def target2yiri(self, event: dict, bot_account_id: str) -> platform_events.MessageEvent:
-        if event['Wxid'] == event['Data']['FromUserName']['string']:
-            return None
-        if event['Data']['FromUserName']['string'].startswith('gh_') or event['Data']['FromUserName'][
-            'string'
-        ].startswith('weixin'):
-            return None
-        message_chain = await self.message_converter.target2yiri(copy.deepcopy(event), bot_account_id)
-
-        if not message_chain:
-            return None
-
-        if '@chatroom' in event['Data']['FromUserName']['string']:
-            sender_wxid = event['Data']['Content']['string'].split(':')[0]
-
-            return platform_events.GroupMessage(
-                sender=platform_entities.GroupMember(
-                    id=sender_wxid,
-                    member_name=event['Data']['FromUserName']['string'],
-                    permission=platform_entities.Permission.Member,
-                    group=platform_entities.Group(
-                        id=event['Data']['FromUserName']['string'],
-                        name=event['Data']['FromUserName']['string'],
-                        permission=platform_entities.Permission.Member,
-                    ),
-                    special_title='',
-                ),
-                message_chain=message_chain,
-                time=event['Data']['CreateTime'],
-                source_platform_object=event,
-            )
-        else:
-            return platform_events.FriendMessage(
-                sender=platform_entities.Friend(
-                    id=event['Data']['FromUserName']['string'],
-                    nickname=event['Data']['FromUserName']['string'],
-                    remark='',
-                ),
-                message_chain=message_chain,
-                time=event['Data']['CreateTime'],
-                source_platform_object=event,
-            )
-
-
-class GeWeChatAdapter(abstract_platform_adapter.AbstractMessagePlatformAdapter):
-    bot: gewechat_client.GewechatClient = None
-    bot_uuid: str = None
-    message_converter: GewechatMessageConverter = None
-    event_converter: GewechatEventConverter = None
-
-    listeners: typing.Dict[
-        typing.Type[platform_events.Event],
-        typing.Callable[[platform_events.Event, abstract_platform_adapter.AbstractMessagePlatformAdapter], None],
-    ] = {}
-
-    def __init__(self, config: dict, logger: EventLogger):
-        super().__init__(
-            config=config,
-            logger=logger,
-        )
-
-        self.message_converter = GewechatMessageConverter(config)
-        self.event_converter = GewechatEventConverter(config)
-
-    def set_bot_uuid(self, bot_uuid: str):
-        self.bot_uuid = bot_uuid
-
-    async def handle_unified_webhook(self, bot_uuid: str, path: str, request):
-        data = await request.json
-        await self.logger.debug(f'Gewechat callback event: {data}')
-
-        if 'data' in data:
-            data['Data'] = data['data']
-        if 'type_name' in data:
-            data['TypeName'] = data['type_name']
-
-        if 'testMsg' in data:
-            return 'ok'
-        elif 'TypeName' in data and data['TypeName'] == 'AddMsg':
-            try:
-                event = await self.event_converter.target2yiri(data.copy(), self.bot_account_id)
-            except Exception:
-                await self.logger.error(f'Error in gewechat callback: {traceback.format_exc()}')
-                return 'ok'
-
-            if event and event.__class__ in self.listeners:
-                await self.listeners[event.__class__](event, self)
-
-            return 'ok'
-
-        return 'ok'
-
-    async def _handle_message(self, message: platform_message.MessageChain, target_id: str):
-        content_list = await self.message_converter.yiri2target(message)
-        at_targets = [item['target'] for item in content_list if item['type'] == 'at']
-
-        at_targets = at_targets or []
-        member_info = []
-        if at_targets:
-            member_info = self.bot.get_chatroom_member_detail(self.config['app_id'], target_id, at_targets[::-1])[
-                'data'
-            ]
-
-        for msg in content_list:
-            if msg['type'] == 'text' and at_targets:
-                for member in member_info:
-                    msg['content'] = f'@{member["nickName"]} {msg["content"]}'
-
-            handler_map = {
-                'text': lambda msg: self.bot.post_text(
-                    app_id=self.config['app_id'],
-                    to_wxid=target_id,
-                    content=msg['content'],
-                    ats=','.join(at_targets),
-                ),
-                'image': lambda msg: self.bot.post_image(
-                    app_id=self.config['app_id'],
-                    to_wxid=target_id,
-                    img_url=msg['image'],
-                ),
-                'WeChatForwardMiniPrograms': lambda msg: self.bot.forward_mini_app(
-                    app_id=self.config['app_id'],
-                    to_wxid=target_id,
-                    xml=msg['xml_data'],
-                    cover_img_url=msg.get('image_url'),
-                ),
-                'WeChatEmoji': lambda msg: self.bot.post_emoji(
-                    app_id=self.config['app_id'],
-                    to_wxid=target_id,
-                    emoji_md5=msg['emoji_md5'],
-                    emoji_size=msg['emoji_size'],
-                ),
-                'WeChatLink': lambda msg: self.bot.post_link(
-                    app_id=self.config['app_id'],
-                    to_wxid=target_id,
-                    title=msg['link_title'],
-                    desc=msg['link_desc'],
-                    link_url=msg['link_url'],
-                    thumb_url=msg['link_thumb_url'],
-                ),
-                'WeChatMiniPrograms': lambda msg: self.bot.post_mini_app(
-                    app_id=self.config['app_id'],
-                    to_wxid=target_id,
-                    mini_app_id=msg['mini_app_id'],
-                    display_name=msg['display_name'],
-                    page_path=msg['page_path'],
-                    cover_img_url=msg['cover_img_url'],
-                    title=msg['title'],
-                    user_name=msg['user_name'],
-                ),
-                'WeChatForwardLink': lambda msg: self.bot.forward_url(
-                    app_id=self.config['app_id'], to_wxid=target_id, xml=msg['xml_data']
-                ),
-                'WeChatForwardImage': lambda msg: self.bot.forward_image(
-                    app_id=self.config['app_id'], to_wxid=target_id, xml=msg['xml_data']
-                ),
-                'WeChatForwardFile': lambda msg: self.bot.forward_file(
-                    app_id=self.config['app_id'], to_wxid=target_id, xml=msg['xml_data']
-                ),
-                'voice': lambda msg: self.bot.post_voice(
-                    app_id=self.config['app_id'],
-                    to_wxid=target_id,
-                    voice_url=msg['url'],
-                    voice_duration=msg['length'],
-                ),
-                'WeChatAppMsg': lambda msg: self.bot.post_app_msg(
-                    app_id=self.config['app_id'],
-                    to_wxid=target_id,
-                    appmsg=msg['app_msg'],
-                ),
-                'at': lambda msg: None,
-            }
-
-            if handler := handler_map.get(msg['type']):
-                handler(msg)
-            else:
-                await self.logger.warning(f'未处理的消息类型: {msg["type"]}')
-                continue
-
-    async def send_message(self, target_type: str, target_id: str, message: platform_message.MessageChain):
-        return await self._handle_message(message, target_id)
-
-    async def reply_message(
-        self,
-        message_source: platform_events.MessageEvent,
-        message: platform_message.MessageChain,
-        quote_origin: bool = False,
-    ):
-        if message_source.source_platform_object:
-            target_id = message_source.source_platform_object['Data']['FromUserName']['string']
-            return await self._handle_message(message, target_id)
-
-    async def is_muted(self, group_id: int) -> bool:
-        pass
-
-    def register_listener(
-        self,
-        event_type: typing.Type[platform_events.Event],
-        callback: typing.Callable[
-            [platform_events.Event, abstract_platform_adapter.AbstractMessagePlatformAdapter], None
-        ],
-    ):
-        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
-        ],
-    ):
-        pass
-
-    def _build_callback_url(self) -> str:
-        webhook_prefix = self.config.get('_webhook_prefix', 'http://127.0.0.1:5300').rstrip('/')
-        return f'{webhook_prefix}/bots/{self.bot_uuid}'
-
-    async def run_async(self):
-        if not self.config['token']:
-            session = httpclient.get_session()
-            async with session.post(
-                f'{self.config["gewechat_url"]}/v2/api/tools/getTokenId',
-                json={'app_id': self.config['app_id']},
-            ) as response:
-                if response.status != 200:
-                    raise Exception(f'获取gewechat token失败: {await response.text()}')
-                self.config['token'] = (await response.json())['data']
-
-        self.bot = gewechat_client.GewechatClient(f'{self.config["gewechat_url"]}/v2/api', self.config['token'])
-
-        def gewechat_init_process():
-            profile = self.bot.get_profile(self.config['app_id'])
-            self.bot_account_id = profile['data']['nickName']
-
-            try:
-                callback_url = self._build_callback_url()
-                self.bot.set_callback(self.config['token'], callback_url)
-                print(f'Gewechat 回调地址已设置: {callback_url}')
-            except Exception as e:
-                raise Exception(f'设置 Gewechat 回调失败，token失效：{e}')
-
-        threading.Thread(target=gewechat_init_process).start()
-
-        # 统一 webhook 模式下，不启动独立的 HTTP 服务
-        # 保持适配器运行
-        while True:
-            await asyncio.sleep(1)
-
-    async def kill(self) -> bool:
-        return False

src/langbot/pkg/platform/sources/gewechat.yaml

@@ -1,51 +0,0 @@
-apiVersion: v1
-kind: MessagePlatformAdapter
-metadata:
-  name: gewechat
-  label:
-    en_US: GeWeChat
-    zh_Hans: GeWeChat（个人微信）
-  description:
-    en_US: GeWeChat Adapter (Unified Webhook)
-    zh_Hans: GeWeChat 适配器（统一 Webhook），请查看文档了解使用方式
-  icon: gewechat.png
-spec:
-  config:
-    - name: gewechat_url
-      label:
-        en_US: GeWeChat URL
-        zh_Hans: GeWeChat URL
-      description:
-        en_US: GeWeChat API server address, e.g. http://127.0.0.1:2531
-        zh_Hans: GeWeChat API 服务器地址，如 http://127.0.0.1:2531
-      type: string
-      required: true
-      default: ""
-    - name: gewechat_file_url
-      label:
-        en_US: GeWeChat file download URL
-        zh_Hans: GeWeChat 文件下载URL
-      description:
-        en_US: GeWeChat file download service address
-        zh_Hans: GeWeChat 文件下载服务地址
-      type: string
-      required: true
-      default: ""
-    - name: app_id
-      label:
-        en_US: App ID
-        zh_Hans: 应用ID
-      type: string
-      required: true
-      default: ""
-    - name: token
-      label:
-        en_US: Token
-        zh_Hans: 令牌
-      type: string
-      required: true
-      default: ""
-execution:
-  python:
-    path: ./gewechat.py
-    attr: GeWeChatAdapter

src/langbot/pkg/platform/sources/lark.py

@@ -575,127 +575,6 @@ class LarkMessageConverter(abstract_platform_adapter.AbstractMessageConverter):
 
 
 class LarkEventConverter(abstract_platform_adapter.AbstractEventConverter):
-    _processed_thread_quote_cache: typing.ClassVar[dict[str, float]] = {}
-    _processed_thread_quote_cache_max_size: typing.ClassVar[int] = 4096
-    _processed_thread_quote_cache_ttl_seconds: typing.ClassVar[int] = 86400
-
-    @classmethod
-    def _prune_processed_thread_quote_cache(cls, now: typing.Optional[float] = None) -> None:
-        if now is None:
-            now = time.time()
-
-        expire_before = now - cls._processed_thread_quote_cache_ttl_seconds
-        while cls._processed_thread_quote_cache:
-            oldest_key, oldest_ts = next(iter(cls._processed_thread_quote_cache.items()))
-            if oldest_ts >= expire_before:
-                break
-            cls._processed_thread_quote_cache.pop(oldest_key, None)
-
-        while len(cls._processed_thread_quote_cache) > cls._processed_thread_quote_cache_max_size:
-            oldest_key = next(iter(cls._processed_thread_quote_cache))
-            cls._processed_thread_quote_cache.pop(oldest_key, None)
-
-    @classmethod
-    def _mark_thread_quote_processed(cls, thread_id: str) -> None:
-        now = time.time()
-        cls._prune_processed_thread_quote_cache(now)
-        cls._processed_thread_quote_cache[thread_id] = now
-
-    @classmethod
-    def _extract_quote_message_id(cls, message: EventMessage) -> typing.Optional[str]:
-        """
-        Extract the message ID to quote from the given message.
-
-        Rules:
-        - First thread reply in a topic: return parent_id and mark topic as processed
-        - Follow-up thread replies in the same topic: return None
-        - Non-thread message: return parent_id if valid (non-empty, different from message_id)
-
-        Thread reply state is kept in a bounded TTL cache to avoid unbounded memory growth.
-        """
-        parent_id = getattr(message, 'parent_id', None)
-        if not parent_id:
-            return None
-
-        message_id = getattr(message, 'message_id', None)
-        if parent_id == message_id:
-            return None
-
-        thread_id = getattr(message, 'thread_id', None)
-        if thread_id:
-            cls._prune_processed_thread_quote_cache()
-            if thread_id in cls._processed_thread_quote_cache:
-                return None
-            cls._mark_thread_quote_processed(thread_id)
-
-        return parent_id
-
-    @staticmethod
-    def _build_event_message_from_message_item(message_item: Message) -> typing.Optional[EventMessage]:
-        """
-        Build EventMessage from SDK typed Message item.
-
-        Returns None if body or content is missing.
-        """
-        body = getattr(message_item, 'body', None)
-        if not body:
-            return None
-
-        content = getattr(body, 'content', None)
-        if not content:
-            return None
-
-        event_data = {
-            'message_id': message_item.message_id,
-            'message_type': message_item.msg_type,
-            'content': content,
-            'create_time': message_item.create_time,
-            'mentions': getattr(message_item, 'mentions', []) or [],
-        }
-
-        # Preserve thread-related fields
-        if hasattr(message_item, 'parent_id') and message_item.parent_id:
-            event_data['parent_id'] = message_item.parent_id
-        if hasattr(message_item, 'root_id') and message_item.root_id:
-            event_data['root_id'] = message_item.root_id
-        if hasattr(message_item, 'thread_id') and message_item.thread_id:
-            event_data['thread_id'] = message_item.thread_id
-        if hasattr(message_item, 'chat_id') and message_item.chat_id:
-            event_data['chat_id'] = message_item.chat_id
-
-        return EventMessage(event_data)
-
-    @staticmethod
-    async def _fetch_quoted_message(
-        quote_message_id: str,
-        api_client: lark_oapi.Client,
-    ) -> typing.Optional[platform_message.MessageChain]:
-        """
-        Fetch the quoted message and convert to MessageChain.
-
-        Returns None if:
-        - API call fails
-        - Response items is empty
-        - Message item normalization fails
-        """
-        request = GetMessageRequest.builder().message_id(quote_message_id).build()
-        response = await api_client.im.v1.message.aget(request)
-
-        if not response.success():
-            return None
-
-        items = getattr(response.data, 'items', None)
-        if not items:
-            return None
-
-        message_item = items[0]
-        event_message = LarkEventConverter._build_event_message_from_message_item(message_item)
-        if event_message is None:
-            return None
-
-        quote_chain = await LarkMessageConverter.target2yiri(event_message, api_client)
-        return quote_chain
-
     @staticmethod
     async def yiri2target(
         event: platform_events.MessageEvent,
@@ -708,23 +587,6 @@ class LarkEventConverter(abstract_platform_adapter.AbstractEventConverter):
     ) -> platform_events.Event:
         message_chain = await LarkMessageConverter.target2yiri(event.event.message, api_client)
 
-        # Check for quote/reply message
-        quote_message_id = LarkEventConverter._extract_quote_message_id(event.event.message)
-        if quote_message_id:
-            quote_chain = await LarkEventConverter._fetch_quoted_message(quote_message_id, api_client)
-            if quote_chain:
-                # Filter out Source component from quoted chain, keep only content
-                quote_origin = platform_message.MessageChain(
-                    [comp for comp in quote_chain if not isinstance(comp, platform_message.Source)]
-                )
-                if quote_origin:
-                    message_chain.append(
-                        platform_message.Quote(
-                            message_id=quote_message_id,
-                            origin=quote_origin,
-                        )
-                    )
-
         if event.event.message.chat_type == 'p2p':
             return platform_events.FriendMessage(
                 sender=platform_entities.Friend(
@@ -908,32 +770,6 @@ class LarkAdapter(abstract_platform_adapter.AbstractMessagePlatformAdapter):
             self.request_tenant_access_token(tenant_key)
         return self.tenant_access_tokens.get(tenant_key)['token'] if self.tenant_access_tokens.get(tenant_key) else None
 
-    def get_launcher_id(self, event: platform_events.MessageEvent) -> str | None:
-        """
-        Get topic-scoped launcher_id for thread-aware session isolation.
-
-        For group thread messages, returns "{group_id}_{thread_id}"
-        to ensure conversation context stays stable per topic.
-
-        Returns None for non-thread messages or P2P messages.
-        """
-        source_event = getattr(event.source_platform_object, 'event', None)
-        if not source_event:
-            return None
-
-        message = getattr(source_event, 'message', None)
-        if not message:
-            return None
-
-        thread_id = getattr(message, 'thread_id', None)
-        if not thread_id:
-            return None
-
-        if isinstance(event, platform_events.GroupMessage):
-            return f'{event.group.id}_{thread_id}'
-
-        return None
-
     def build_api_client(self, config):
         app_id = config['app_id']
         app_secret = config['app_secret']

src/langbot/pkg/platform/sources/telegram.py

@@ -42,25 +42,6 @@ class TelegramMessageConverter(abstract_platform_adapter.AbstractMessageConverte
                         photo_bytes = f.read()
 
                 components.append({'type': 'photo', 'photo': photo_bytes})
-            elif isinstance(component, platform_message.File):
-                file_bytes = None
-
-                if component.base64:
-                    # Strip data URI prefix if present (e.g. "data:application/pdf;base64,...")
-                    b64_data = component.base64
-                    if ';base64,' in b64_data:
-                        b64_data = b64_data.split(';base64,', 1)[1]
-                    file_bytes = base64.b64decode(b64_data)
-                elif component.url:
-                    session = httpclient.get_session()
-                    async with session.get(component.url) as response:
-                        file_bytes = await response.read()
-                elif component.path:
-                    with open(component.path, 'rb') as f:
-                        file_bytes = f.read()
-
-                file_name = getattr(component, 'name', None) or 'file'
-                components.append({'type': 'document', 'document': file_bytes, 'filename': file_name})
             elif isinstance(component, platform_message.Forward):
                 for node in component.node_list:
                     components.extend(await TelegramMessageConverter.yiri2target(node.message_chain, bot))
@@ -123,27 +104,6 @@ class TelegramMessageConverter(abstract_platform_adapter.AbstractMessageConverte
                 )
             )
 
-        if message.document:
-            if message.caption:
-                message_components.extend(parse_message_text(message.caption))
-
-            file = await message.document.get_file()
-            file_name = message.document.file_name or 'document'
-            file_size = message.document.file_size or 0
-            file_format = message.document.mime_type or 'application/octet-stream'
-
-            file_bytes = None
-            async with httpclient.get_session(trust_env=True).get(file.file_path) as response:
-                file_bytes = await response.read()
-
-            message_components.append(
-                platform_message.File(
-                    name=file_name,
-                    size=file_size,
-                    base64=f'data:{file_format};base64,{base64.b64encode(file_bytes).decode("utf-8")}',
-                )
-            )
-
         return platform_message.MessageChain(message_components)
 
 
@@ -219,10 +179,7 @@ class TelegramAdapter(abstract_platform_adapter.AbstractMessagePlatformAdapter):
         application = ApplicationBuilder().token(config['token']).build()
         bot = application.bot
         application.add_handler(
-            MessageHandler(
-                filters.TEXT | (filters.COMMAND) | filters.PHOTO | filters.VOICE | filters.Document.ALL,
-                telegram_callback,
-            )
+            MessageHandler(filters.TEXT | (filters.COMMAND) | filters.PHOTO | filters.VOICE, telegram_callback)
         )
         super().__init__(
             config=config,
@@ -261,13 +218,6 @@ class TelegramAdapter(abstract_platform_adapter.AbstractMessagePlatformAdapter):
                     continue
                 args['photo'] = telegram.InputFile(photo)
                 await self.bot.send_photo(**args)
-            elif component_type == 'document':
-                doc = component.get('document')
-                if doc is None:
-                    continue
-                filename = component.get('filename', 'file')
-                args['document'] = telegram.InputFile(doc, filename=filename)
-                await self.bot.send_document(**args)
 
     async def reply_message(
         self,

src/langbot/pkg/platform/sources/wecombot.py

@@ -11,7 +11,6 @@ import langbot_plugin.api.entities.builtin.platform.entities as platform_entitie
 from ..logger import EventLogger
 from langbot.libs.wecom_ai_bot_api.wecombotevent import WecomBotEvent
 from langbot.libs.wecom_ai_bot_api.api import WecomBotClient
-from langbot.libs.wecom_ai_bot_api.ws_client import WecomBotWsClient
 
 
 class WecomBotMessageConverter(abstract_platform_adapter.AbstractMessageConverter):
@@ -24,18 +23,14 @@ class WecomBotMessageConverter(abstract_platform_adapter.AbstractMessageConverte
         return content
 
     @staticmethod
-    async def target2yiri(event: WecomBotEvent, bot_name: str = ''):
+    async def target2yiri(event: WecomBotEvent):
         yiri_msg_list = []
         if event.type == 'group':
             yiri_msg_list.append(platform_message.At(target=event.ai_bot_id))
-
         yiri_msg_list.append(platform_message.Source(id=event.message_id, time=datetime.datetime.now()))
 
         if event.content:
-            content = event.content
-            if bot_name:
-                content = content.replace(f'@{bot_name}', '').strip()
-            yiri_msg_list.append(platform_message.Plain(text=content))
+            yiri_msg_list.append(platform_message.Plain(text=event.content))
 
         images = []
         if event.images:
@@ -138,15 +133,13 @@ class WecomBotMessageConverter(abstract_platform_adapter.AbstractMessageConverte
 
 
 class WecomBotEventConverter(abstract_platform_adapter.AbstractEventConverter):
-    def __init__(self, bot_name: str = ''):
-        self.bot_name = bot_name
-
     @staticmethod
     async def yiri2target(event: platform_events.MessageEvent):
         return event.source_platform_object
 
-    async def target2yiri(self, event: WecomBotEvent):
-        message_chain = await WecomBotMessageConverter.target2yiri(event, bot_name=self.bot_name)
+    @staticmethod
+    async def target2yiri(event: WecomBotEvent):
+        message_chain = await WecomBotMessageConverter.target2yiri(event)
         if event.type == 'single':
             return platform_events.FriendMessage(
                 sender=platform_entities.Friend(
@@ -183,53 +176,34 @@ class WecomBotEventConverter(abstract_platform_adapter.AbstractEventConverter):
 
 
 class WecomBotAdapter(abstract_platform_adapter.AbstractMessagePlatformAdapter):
-    bot: typing.Union[WecomBotClient, WecomBotWsClient]
+    bot: WecomBotClient
     bot_account_id: str
     message_converter: WecomBotMessageConverter = WecomBotMessageConverter()
-    event_converter: WecomBotEventConverter
+    event_converter: WecomBotEventConverter = WecomBotEventConverter()
     config: dict
     bot_uuid: str = None
-    _ws_mode: bool = False
-    bot_name: str = ''
-    listeners: dict = {}
 
     def __init__(self, config: dict, logger: EventLogger):
-        enable_webhook = config.get('enable-webhook', False)
-        bot_name = config.get('robot_name', '')
+        required_keys = ['Token', 'EncodingAESKey', 'Corpid', 'BotId']
+        missing_keys = [key for key in required_keys if key not in config]
+        if missing_keys:
+            raise Exception(f'WecomBot 缺少配置项: {missing_keys}')
 
-        if not enable_webhook:
-            bot = WecomBotWsClient(
-                bot_id=config['BotId'],
-                secret=config['Secret'],
-                logger=logger,
-                encoding_aes_key=config.get('EncodingAESKey', ''),
-            )
-        else:
-            # Webhook callback mode
-            required_keys = ['Token', 'EncodingAESKey', 'Corpid']
-            missing_keys = [key for key in required_keys if key not in config or not config[key]]
-            if missing_keys:
-                raise Exception(f'WecomBot webhook mode missing config: {missing_keys}')
+        bot = WecomBotClient(
+            Token=config['Token'],
+            EnCodingAESKey=config['EncodingAESKey'],
+            Corpid=config['Corpid'],
+            logger=logger,
+            unified_mode=True,
+        )
+        bot_account_id = config['BotId']
 
-            bot = WecomBotClient(
-                Token=config['Token'],
-                EnCodingAESKey=config['EncodingAESKey'],
-                Corpid=config['Corpid'],
-                logger=logger,
-                unified_mode=True,
-            )
-
-        bot_account_id = config.get('BotId', '')
-        event_converter = WecomBotEventConverter(bot_name=bot_name)
         super().__init__(
             config=config,
             logger=logger,
             bot=bot,
             bot_account_id=bot_account_id,
-            bot_name=bot_name,
-            event_converter=event_converter,
         )
-        self.listeners = {}
 
     async def reply_message(
         self,
@@ -238,17 +212,7 @@ class WecomBotAdapter(abstract_platform_adapter.AbstractMessagePlatformAdapter):
         quote_origin: bool = False,
     ):
         content = await self.message_converter.yiri2target(message)
-        _ws_mode = not self.config.get('enable-webhook', False)
-
-        if _ws_mode:
-            event = message_source.source_platform_object
-            req_id = event.get('req_id', '')
-            if req_id:
-                await self.bot.reply_text(req_id, content)
-            else:
-                await self.bot.set_message(event.message_id, content)
-        else:
-            await self.bot.set_message(message_source.source_platform_object.message_id, content)
+        await self.bot.set_message(message_source.source_platform_object.message_id, content)
 
     async def reply_message_chunk(
         self,
@@ -258,23 +222,31 @@ class WecomBotAdapter(abstract_platform_adapter.AbstractMessagePlatformAdapter):
         quote_origin: bool = False,
         is_final: bool = False,
     ):
+        """将流水线增量输出写入企业微信 stream 会话。
+
+        Args:
+            message_source: 流水线提供的原始消息事件。
+            bot_message: 当前片段对应的模型元信息（未使用）。
+            message: 需要回复的消息链。
+            quote_origin: 是否引用原消息（企业微信暂不支持）。
+            is_final: 标记当前片段是否为最终回复。
+
+        Returns:
+            dict: 包含 `stream` 键，标识写入是否成功。
+
+        Example:
+            在流水线 `reply_message_chunk` 调用中自动触发，无需手动调用。
+        """
+        # 转换为纯文本（智能机器人当前协议仅支持文本流）
         content = await self.message_converter.yiri2target(message)
         msg_id = message_source.source_platform_object.message_id
-        _ws_mode = not self.config.get('enable-webhook', False)
 
-        if _ws_mode:
-            success = await self.bot.push_stream_chunk(msg_id, content, is_final=is_final)
-            if not success and is_final:
-                event = message_source.source_platform_object
-                req_id = event.get('req_id', '')
-                if req_id:
-                    await self.bot.reply_text(req_id, content)
-            return {'stream': success}
-        else:
-            success = await self.bot.push_stream_chunk(msg_id, content, is_final=is_final)
-            if not success and is_final:
-                await self.bot.set_message(msg_id, content)
-            return {'stream': success}
+        # 将片段推送到 WecomBotClient 中的队列，返回值用于判断是否走降级逻辑
+        success = await self.bot.push_stream_chunk(msg_id, content, is_final=is_final)
+        if not success and is_final:
+            # 未命中流式队列时使用旧有 set_message 兜底
+            await self.bot.set_message(msg_id, content)
+        return {'stream': success}
 
     async def is_stream_output_supported(self) -> bool:
         """智能机器人侧默认开启流式能力。
@@ -287,21 +259,7 @@ class WecomBotAdapter(abstract_platform_adapter.AbstractMessagePlatformAdapter):
         return True
 
     async def send_message(self, target_type, target_id, message):
-        _ws_mode = not self.config.get('enable-webhook', False)
-        if _ws_mode:
-            content = await self.message_converter.yiri2target(message)
-            await self.bot.send_message(target_id, content)
-        else:
-            pass
-
-    async def on_message(self, event: WecomBotEvent):
-        try:
-            lb_event = await self.event_converter.target2yiri(event)
-            if lb_event:
-                await self.listeners[type(lb_event)](lb_event, self)
-        except Exception:
-            await self.logger.error(f'Error in wecombot callback: {traceback.format_exc()}')
-            print(traceback.format_exc())
+        pass
 
     def register_listener(
         self,
@@ -310,13 +268,18 @@ class WecomBotAdapter(abstract_platform_adapter.AbstractMessagePlatformAdapter):
             [platform_events.Event, abstract_platform_adapter.AbstractMessagePlatformAdapter], None
         ],
     ):
-        self.listeners[event_type] = callback
+        async def on_message(event: WecomBotEvent):
+            try:
+                return await callback(await self.event_converter.target2yiri(event), self)
+            except Exception:
+                await self.logger.error(f'Error in wecombot callback: {traceback.format_exc()}')
+                print(traceback.format_exc())
 
         try:
             if event_type == platform_events.FriendMessage:
-                self.bot.on_message('single')(self.on_message)
+                self.bot.on_message('single')(on_message)
             elif event_type == platform_events.GroupMessage:
-                self.bot.on_message('group')(self.on_message)
+                self.bot.on_message('group')(on_message)
         except Exception:
             print(traceback.format_exc())
 
@@ -325,28 +288,29 @@ class WecomBotAdapter(abstract_platform_adapter.AbstractMessagePlatformAdapter):
         self.bot_uuid = bot_uuid
 
     async def handle_unified_webhook(self, bot_uuid: str, path: str, request):
-        _ws_mode = not self.config.get('enable-webhook', False)
-        if _ws_mode:
-            return None
+        """处理统一 webhook 请求。
+
+        Args:
+            bot_uuid: Bot 的 UUID
+            path: 子路径（如果有的话）
+            request: Quart Request 对象
+
+        Returns:
+            响应数据
+        """
         return await self.bot.handle_unified_webhook(request)
 
     async def run_async(self):
-        _ws_mode = not self.config.get('enable-webhook', False)
-        if _ws_mode:
-            await self.bot.connect()
-        else:
+        # 统一 webhook 模式下，不启动独立的 Quart 应用
+        # 保持运行但不启动独立端口
 
-            async def keep_alive():
-                while True:
-                    await asyncio.sleep(1)
+        async def keep_alive():
+            while True:
+                await asyncio.sleep(1)
 
-            await keep_alive()
+        await keep_alive()
 
     async def kill(self) -> bool:
-        _ws_mode = not self.config.get('enable-webhook', False)
-        if _ws_mode:
-            await self.bot.disconnect()
-            return True
         return False
 
     async def unregister_listener(

src/langbot/pkg/platform/sources/wecombot.yaml

@@ -11,71 +11,35 @@ metadata:
   icon: wecombot.png
 spec:
   config:
-    - name: BotId
-      label:
-        en_US: BotId
-        zh_Hans: 机器人ID (BotId)
-      type: string
-      required: true
-      default: ""
-    - name: robot_name
-      label:
-        en_US: Robot Name
-        zh_Hans: 机器人名称
-      type: string
-      required: true
-      default: ""
-    - name: enable-webhook
-      label:
-        en_US: Enable Webhook Mode
-        zh_Hans: 启用Webhook模式
-      description:
-        en_US: If enabled, the bot will use webhook mode to receive messages. Otherwise, it will use WS long connection mode
-        zh_Hans: 如果启用，机器人将使用 Webhook 模式接收消息。否则，将使用 WS 长连接模式
-      type: boolean
-      required: true
-      default: false
-    - name: Secret
-      label:
-        en_US: Secret
-        zh_Hans: 机器人密钥 (Secret)
-      description:
-        en_US: Required for WebSocket long connection mode
-        zh_Hans: 使用 WS 长连接模式时必填
-      type: string
-      required: false
-      default: ""
     - name: Corpid
       label:
         en_US: Corpid
         zh_Hans: 企业ID
-      description:
-        en_US: Required for Webhook mode
-        zh_Hans: 使用 Webhook 模式时必填
       type: string
-      required: false
+      required: true
       default: ""
     - name: Token
       label:
         en_US: Token
         zh_Hans: 令牌 (Token)
-      description:
-        en_US: Required for Webhook mode
-        zh_Hans: 使用 Webhook 模式时必填
       type: string
-      required: false
+      required: true
       default: ""
     - name: EncodingAESKey
       label:
         en_US: EncodingAESKey
         zh_Hans: 消息加解密密钥 (EncodingAESKey)
-      description:
-        en_US: Required for Webhook mode. Optional for WebSocket mode (used for file decryption)
-        zh_Hans: 使用 Webhook 模式时必填。WebSocket 模式下可选（用于文件解密）
+      type: string
+      required: true
+      default: ""
+    - name: BotId
+      label:
+        en_US: BotId
+        zh_Hans: 机器人ID
       type: string
       required: false
       default: ""
 execution:
   python:
     path: ./wecombot.py
-    attr: WecomBotAdapter
+    attr: WecomBotAdapter

src/langbot/pkg/plugin/handler.py

@@ -555,18 +555,6 @@ class RuntimeConnectionHandler(handler.Handler):
             except Exception as e:
                 return _make_rag_error_response(e, 'VectorStoreError', collection_id=collection_id)
 
-        @self.action(PluginToRuntimeAction.VECTOR_LIST)
-        async def vector_list(data: dict[str, Any]) -> handler.ActionResponse:
-            collection_id = data['collection_id']
-            filters = data.get('filters')
-            limit = data.get('limit', 20)
-            offset = data.get('offset', 0)
-            try:
-                items, total = await self.ap.rag_runtime_service.vector_list(collection_id, filters, limit, offset)
-                return handler.ActionResponse.success(data={'items': items, 'total': total})
-            except Exception as e:
-                return _make_rag_error_response(e, 'VectorStoreError', collection_id=collection_id)
-
         @self.action(PluginToRuntimeAction.GET_KNOWLEDEGE_FILE_STREAM)
         async def get_knowledge_file_stream(data: dict[str, Any]) -> handler.ActionResponse:
             storage_path = data['storage_path']
@@ -577,16 +565,6 @@ class RuntimeConnectionHandler(handler.Handler):
             except Exception as e:
                 return _make_rag_error_response(e, 'FileServiceError', storage_path=storage_path)
 
-        @self.action(PluginToRuntimeAction.LIST_PARSERS)
-        async def list_parsers(data: dict[str, Any]) -> handler.ActionResponse:
-            """Plugin requests host to list available parser plugins."""
-            mime_type = data.get('mime_type')
-            try:
-                parsers = await self.ap.knowledge_service.list_parsers(mime_type)
-                return handler.ActionResponse.success(data={'parsers': parsers})
-            except Exception as e:
-                return _make_rag_error_response(e, 'ParserDiscoveryError', mime_type=mime_type)
-
         @self.action(PluginToRuntimeAction.INVOKE_PARSER)
         async def invoke_parser(data: dict[str, Any]) -> handler.ActionResponse:
             """Plugin requests host to invoke a parser plugin."""
@@ -611,98 +589,6 @@ class RuntimeConnectionHandler(handler.Handler):
             except Exception as e:
                 return _make_rag_error_response(e, 'ParserError')
 
-        # ================= Knowledge Base Query APIs =================
-
-        @self.action(PluginToRuntimeAction.LIST_PIPELINE_KNOWLEDGE_BASES)
-        async def list_pipeline_knowledge_bases(data: dict[str, Any]) -> handler.ActionResponse:
-            """List knowledge bases configured for the current query's pipeline."""
-            query_id = data['query_id']
-
-            if query_id not in self.ap.query_pool.cached_queries:
-                return handler.ActionResponse.error(
-                    message=f'Query with query_id {query_id} not found',
-                )
-
-            query = self.ap.query_pool.cached_queries[query_id]
-
-            kb_uuids = []
-            if query.pipeline_config:
-                local_agent_config = query.pipeline_config.get('ai', {}).get('local-agent', {})
-                kb_uuids = local_agent_config.get('knowledge-bases', [])
-                # Backward compatibility
-                if not kb_uuids:
-                    old_kb_uuid = local_agent_config.get('knowledge-base', '')
-                    if old_kb_uuid and old_kb_uuid != '__none__':
-                        kb_uuids = [old_kb_uuid]
-
-            knowledge_bases = []
-            for kb_uuid in kb_uuids:
-                kb = await self.ap.rag_mgr.get_knowledge_base_by_uuid(kb_uuid)
-                if kb:
-                    knowledge_bases.append(
-                        {
-                            'uuid': kb.get_uuid(),
-                            'name': kb.get_name(),
-                            'description': kb.knowledge_base_entity.description or '',
-                        }
-                    )
-
-            return handler.ActionResponse.success(data={'knowledge_bases': knowledge_bases})
-
-        @self.action(PluginToRuntimeAction.RETRIEVE_KNOWLEDGE_BASE)
-        async def retrieve_knowledge_base(data: dict[str, Any]) -> handler.ActionResponse:
-            """Retrieve documents from a knowledge base within the pipeline's scope."""
-            query_id = data['query_id']
-            kb_id = data['kb_id']
-            query_text = data['query_text']
-            top_k = data.get('top_k', 5)
-            filters = data.get('filters', {})
-
-            if query_id not in self.ap.query_pool.cached_queries:
-                return handler.ActionResponse.error(
-                    message=f'Query with query_id {query_id} not found',
-                )
-
-            query = self.ap.query_pool.cached_queries[query_id]
-
-            # Validate kb_id is in pipeline's allowed list
-            allowed_kb_uuids = []
-            if query.pipeline_config:
-                local_agent_config = query.pipeline_config.get('ai', {}).get('local-agent', {})
-                allowed_kb_uuids = local_agent_config.get('knowledge-bases', [])
-                if not allowed_kb_uuids:
-                    old_kb_uuid = local_agent_config.get('knowledge-base', '')
-                    if old_kb_uuid and old_kb_uuid != '__none__':
-                        allowed_kb_uuids = [old_kb_uuid]
-
-            if kb_id not in allowed_kb_uuids:
-                return handler.ActionResponse.error(
-                    message=f'Knowledge base {kb_id} is not configured for this pipeline',
-                )
-
-            kb = await self.ap.rag_mgr.get_knowledge_base_by_uuid(kb_id)
-            if not kb:
-                return handler.ActionResponse.error(
-                    message=f'Knowledge base {kb_id} not found',
-                )
-
-            try:
-                session_name = f'{query.session.launcher_type.value}_{query.session.launcher_id}'
-                entries = await kb.retrieve(
-                    query_text,
-                    settings={
-                        'top_k': top_k,
-                        'filters': filters,
-                        'session_name': session_name,
-                        'bot_uuid': query.bot_uuid or '',
-                        'sender_id': str(query.sender_id),
-                    },
-                )
-                results = [entry.model_dump(mode='json') for entry in entries]
-                return handler.ActionResponse.success(data={'results': results})
-            except Exception as e:
-                return _make_rag_error_response(e, 'RetrievalError', kb_id=kb_id)
-
         @self.action(CommonAction.PING)
         async def ping(data: dict[str, Any]) -> handler.ActionResponse:
             """Ping"""
@@ -1009,7 +895,7 @@ class RuntimeConnectionHandler(handler.Handler):
         result = await self.call_action(
             LangBotToRuntimeAction.RAG_INGEST_DOCUMENT,
             {'plugin_author': plugin_author, 'plugin_name': plugin_name, 'context': context_data},
-            timeout=1200,  # Ingestion can be slow for large documents
+            timeout=300,  # Ingestion can be slow
         )
         return result
 

src/langbot/pkg/provider/modelmgr/requesters/anthropicmsgs.py

@@ -288,10 +288,10 @@ class AnthropicMessages(requester.ProviderAPIRequester):
             think_started = False
             think_ended = False
             finish_reason = False
+            content = ''
             tool_name = ''
             tool_id = ''
             async for chunk in await self.client.messages.create(**args):
-                content = ''
                 tool_call = {'id': None, 'function': {'name': None, 'arguments': None}, 'type': 'function'}
                 if isinstance(
                     chunk, anthropic.types.raw_content_block_start_event.RawContentBlockStartEvent

src/langbot/pkg/provider/runners/localagent.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import json
 import copy
+import asyncio
 import typing
 from .. import runner
 from ..modelmgr import requester as modelmgr_requester
@@ -132,9 +133,14 @@ class LocalAgentRunner(runner.RequestRunner):
         """Run request"""
         pending_tool_calls = []
 
-        # Get knowledge bases list from query variables (set by PreProcessor,
-        # may have been modified by plugins during PromptPreProcessing)
-        kb_uuids = query.variables.get('_knowledge_base_uuids', [])
+        # Get knowledge bases list (new field)
+        kb_uuids = query.pipeline_config['ai']['local-agent'].get('knowledge-bases', [])
+
+        # Fallback to old field for backward compatibility
+        if not kb_uuids:
+            old_kb_uuid = query.pipeline_config['ai']['local-agent'].get('knowledge-base', '')
+            if old_kb_uuid and old_kb_uuid != '__none__':
+                kb_uuids = [old_kb_uuid]
 
         user_message = copy.deepcopy(query.user_message)
 
@@ -163,7 +169,6 @@ class LocalAgentRunner(runner.RequestRunner):
                 result = await kb.retrieve(
                     user_message_text,
                     settings={
-                        'bot_uuid': query.bot_uuid or '',
                         'sender_id': str(query.sender_id),
                         'session_name': f'{query.session.launcher_type.value}_{query.session.launcher_id}',
                     },
@@ -291,28 +296,37 @@ class LocalAgentRunner(runner.RequestRunner):
         # Once a model succeeds, commit to it for the tool call loop
         # (no fallback mid-conversation — different models may interpret tool results differently)
         while pending_tool_calls:
-            for tool_call in pending_tool_calls:
+            # Execute all tool calls in parallel (they are independent within the same batch)
+            async def _execute_single_tool(tc):
+                """Execute a single tool call and return (tool_call, content, error)."""
                 try:
-                    func = tool_call.function
-
-                    if func.arguments:
-                        parameters = json.loads(func.arguments)
-                    else:
-                        parameters = {}
-
+                    func = tc.function
+                    parameters = json.loads(func.arguments) if func.arguments else {}
                     func_ret = await self.ap.tool_mgr.execute_func_call(func.name, parameters, query=query)
 
                     # Handle return value content
-                    tool_content = None
                     if (
                         isinstance(func_ret, list)
                         and len(func_ret) > 0
                         and isinstance(func_ret[0], provider_message.ContentElement)
                     ):
-                        tool_content = func_ret
+                        return tc, func_ret, None
                     else:
-                        tool_content = json.dumps(func_ret, ensure_ascii=False)
+                        return tc, json.dumps(func_ret, ensure_ascii=False), None
+                except Exception as e:
+                    return tc, None, e
 
+            tool_results = await asyncio.gather(*[_execute_single_tool(tc) for tc in pending_tool_calls])
+
+            # Yield results in order and append to messages
+            for tool_call, tool_content, tool_error in tool_results:
+                if tool_error is not None:
+                    err_msg = provider_message.Message(
+                        role='tool', content=f'err: {tool_error}', tool_call_id=tool_call.id
+                    )
+                    yield err_msg
+                    req_messages.append(err_msg)
+                else:
                     if is_stream:
                         msg = provider_message.MessageChunk(
                             role='tool',
@@ -325,16 +339,8 @@ class LocalAgentRunner(runner.RequestRunner):
                             content=tool_content,
                             tool_call_id=tool_call.id,
                         )
-
                     yield msg
-
                     req_messages.append(msg)
-                except Exception as e:
-                    err_msg = provider_message.Message(role='tool', content=f'err: {e}', tool_call_id=tool_call.id)
-
-                    yield err_msg
-
-                    req_messages.append(err_msg)
 
             self.ap.logger.debug(
                 f'localagent req: query={query.query_id} req_messages={req_messages} '

src/langbot/pkg/rag/service/runtime.py

@@ -75,31 +75,6 @@ class RAGRuntimeService:
             count = await self.ap.vector_db_mgr.delete_by_filter(collection_name=collection_id, filter=filters)
         return count
 
-    async def vector_list(
-        self,
-        collection_id: str,
-        filters: dict[str, Any] | None = None,
-        limit: int = 20,
-        offset: int = 0,
-    ) -> tuple[list[dict[str, Any]], int]:
-        """Handle VECTOR_LIST action.
-
-        Args:
-            collection_id: The collection to list from.
-            filters: Optional metadata filters.
-            limit: Maximum number of items to return.
-            offset: Number of items to skip.
-
-        Returns:
-            Tuple of (items, total).
-        """
-        return await self.ap.vector_db_mgr.list_by_filter(
-            collection_name=collection_id,
-            filter=filters,
-            limit=limit,
-            offset=offset,
-        )
-
     async def get_file_stream(self, storage_path: str) -> bytes:
         """Handle GET_KNOWLEDEGE_FILE_STREAM action.
 

src/langbot/pkg/utils/constants.py

@@ -2,7 +2,7 @@ import langbot
 
 semantic_version = f'v{langbot.__version__}'
 
-required_database_version = 24
+required_database_version = 23
 """Tag the version of the database schema, used to check if the database needs to be migrated"""
 
 debug_mode = False

src/langbot/pkg/vector/filter_utils.py

@@ -49,25 +49,17 @@ def normalize_filter(
 def strip_unsupported_fields(
     triples: list[tuple[str, str, Any]],
     supported_fields: set[str],
-    field_aliases: dict[str, str] | None = None,
 ) -> list[tuple[str, str, Any]]:
     """Return only triples whose field is in *supported_fields*.
 
-    If *field_aliases* is provided, aliased field names are mapped to the
-    canonical backend name before the support check.  For example,
-    ``{'uuid': 'chunk_uuid'}`` allows callers to use ``uuid`` which is
-    transparently rewritten to ``chunk_uuid``.
-
     Dropped fields are logged at WARNING level so the caller knows they were
     silently ignored (useful for Milvus / pgvector which only store a fixed
     schema).
     """
-    aliases = field_aliases or {}
     kept: list[tuple[str, str, Any]] = []
     for field, op, value in triples:
-        resolved = aliases.get(field, field)
-        if resolved in supported_fields:
-            kept.append((resolved, op, value))
+        if field in supported_fields:
+            kept.append((field, op, value))
         else:
             logger.warning(
                 'Filter field %r is not supported by this backend and will be ignored (supported: %s)',

src/langbot/pkg/vector/mgr.py

@@ -100,7 +100,7 @@ class VectorDBManager:
     ) -> list[dict]:
         """Proxy: Search vectors.
 
-        Returns a list of dicts with keys: 'id', 'distance', 'metadata'.
+        Returns a list of dicts with keys: 'id', 'score', 'metadata'.
         The underlying VectorDatabase.search returns Chroma-style format:
         { 'ids': [['id1']], 'distances': [[0.1]], 'metadatas': [[{}]] }
         """
@@ -130,7 +130,7 @@ class VectorDBManager:
             parsed_results.append(
                 {
                     'id': id_val,
-                    'distance': r_dists[i] if r_dists and i < len(r_dists) else 0.0,
+                    'score': r_dists[i] if r_dists and i < len(r_dists) else 0.0,
                     'metadata': r_metas[i] if r_metas and i < len(r_metas) else {},
                 }
             )
@@ -157,17 +157,3 @@ class VectorDBManager:
             Number of deleted vectors (best-effort; some backends return 0).
         """
         return await self.vector_db.delete_by_filter(collection_name, filter)
-
-    async def list_by_filter(
-        self,
-        collection_name: str,
-        filter: dict | None = None,
-        limit: int = 20,
-        offset: int = 0,
-    ) -> tuple[list[dict], int]:
-        """Proxy: List vectors by metadata filter with pagination.
-
-        Returns:
-            Tuple of (items, total).
-        """
-        return await self.vector_db.list_by_filter(collection_name, filter, limit, offset)

src/langbot/pkg/vector/vdb.py

@@ -92,28 +92,6 @@ class VectorDatabase(abc.ABC):
         """
         pass
 
-    async def list_by_filter(
-        self,
-        collection: str,
-        filter: dict[str, Any] | None = None,
-        limit: int = 20,
-        offset: int = 0,
-    ) -> tuple[list[dict[str, Any]], int]:
-        """List vectors matching the given metadata filter with pagination.
-
-        Args:
-            collection: Collection name.
-            filter: Optional metadata filter dict in canonical format.
-            limit: Maximum number of items to return.
-            offset: Number of items to skip.
-
-        Returns:
-            Tuple of (items, total) where items is a list of dicts with
-            keys 'id', 'document', 'metadata', and total is the best-effort
-            count of all matching vectors (-1 if unknown).
-        """
-        return [], -1
-
     @abc.abstractmethod
     async def get_or_create_collection(self, collection: str):
         """Get or create collection."""

src/langbot/pkg/vector/vdbs/chroma.py

@@ -221,41 +221,6 @@ class ChromaVectorDatabase(VectorDatabase):
         self.ap.logger.info(f"Deleted embeddings from Chroma collection '{collection}' by filter")
         return 0  # Chroma delete does not return a count
 
-    async def list_by_filter(
-        self,
-        collection: str,
-        filter: dict[str, Any] | None = None,
-        limit: int = 20,
-        offset: int = 0,
-    ) -> tuple[list[dict[str, Any]], int]:
-        col = await self.get_or_create_collection(collection)
-        get_kwargs: dict[str, Any] = dict(
-            include=['metadatas', 'documents'],
-            limit=limit,
-            offset=offset,
-        )
-        if filter:
-            get_kwargs['where'] = filter
-        results = await asyncio.to_thread(col.get, **get_kwargs)
-
-        ids = results.get('ids', [])
-        metadatas = results.get('metadatas', []) or [None] * len(ids)
-        documents = results.get('documents', []) or [None] * len(ids)
-
-        items = []
-        for i, vid in enumerate(ids):
-            items.append(
-                {
-                    'id': vid,
-                    'document': documents[i] if i < len(documents) else None,
-                    'metadata': metadatas[i] if i < len(metadatas) else {},
-                }
-            )
-
-        # Chroma col.count() gives total in collection; filtered count not available
-        total = await asyncio.to_thread(col.count) if not filter else -1
-        return items, total
-
     async def delete_collection(self, collection: str):
         if collection in self._collections:
             del self._collections[collection]

src/langbot/pkg/vector/vdbs/milvus.py

@@ -11,14 +11,11 @@ from langbot.pkg.core import app
 # silently dropped with a warning.
 _MILVUS_SUPPORTED_FIELDS = {'text', 'file_id', 'chunk_uuid'}
 
-# Callers use canonical metadata key 'uuid' but Milvus stores it as 'chunk_uuid'.
-_MILVUS_FIELD_ALIASES = {'uuid': 'chunk_uuid'}
-
 
 def _build_milvus_expr(filter_dict: dict[str, Any]) -> str:
     """Translate canonical filter dict into a Milvus boolean expression string."""
     triples = normalize_filter(filter_dict)
-    triples = strip_unsupported_fields(triples, _MILVUS_SUPPORTED_FIELDS, _MILVUS_FIELD_ALIASES)
+    triples = strip_unsupported_fields(triples, _MILVUS_SUPPORTED_FIELDS)
     if not triples:
         return ''
 
@@ -343,62 +340,6 @@ class MilvusVectorDatabase(VectorDatabase):
         self.ap.logger.info(f"Deleted embeddings from Milvus collection '{collection}' by filter")
         return 0  # Milvus delete does not return a count
 
-    async def list_by_filter(
-        self,
-        collection: str,
-        filter: dict[str, Any] | None = None,
-        limit: int = 20,
-        offset: int = 0,
-    ) -> tuple[list[dict[str, Any]], int]:
-        collection = self._normalize_collection_name(collection)
-        await self.get_or_create_collection(collection)
-
-        query_kwargs: dict[str, Any] = dict(
-            collection_name=collection,
-            output_fields=['text', 'file_id', 'chunk_uuid'],
-            limit=limit,
-            offset=offset,
-        )
-        if filter:
-            expr = _build_milvus_expr(filter)
-            if expr:
-                query_kwargs['filter'] = expr
-
-        results = await asyncio.to_thread(self.client.query, **query_kwargs)
-
-        items = []
-        for row in results:
-            items.append(
-                {
-                    'id': row.get('id', ''),
-                    'document': row.get('text'),
-                    'metadata': {
-                        'text': row.get('text', ''),
-                        'file_id': row.get('file_id', ''),
-                        'uuid': row.get('chunk_uuid', ''),
-                    },
-                }
-            )
-
-        # Milvus query with count(*)
-        total = -1
-        try:
-            count_kwargs: dict[str, Any] = dict(
-                collection_name=collection,
-                output_fields=['count(*)'],
-            )
-            if filter:
-                expr = _build_milvus_expr(filter)
-                if expr:
-                    count_kwargs['filter'] = expr
-            count_result = await asyncio.to_thread(self.client.query, **count_kwargs)
-            if count_result:
-                total = count_result[0].get('count(*)', -1)
-        except Exception:
-            pass
-
-        return items, total
-
     async def delete_collection(self, collection: str):
         """Delete a Milvus collection
 

src/langbot/pkg/vector/vdbs/pgvector_db.py

@@ -13,9 +13,6 @@ Base = declarative_base()
 # pgvector schema only stores these metadata fields.
 _PG_SUPPORTED_FIELDS = {'text', 'file_id', 'chunk_uuid'}
 
-# Callers use canonical metadata key 'uuid' but pgvector stores it as 'chunk_uuid'.
-_PG_FIELD_ALIASES = {'uuid': 'chunk_uuid'}
-
 # Map schema field names to SQLAlchemy columns (resolved lazily from PgVectorEntry).
 _PG_COLUMN_MAP = {
     'text': 'text',
@@ -40,7 +37,7 @@ class PgVectorEntry(Base):
 def _build_pg_conditions(filter_dict: dict[str, Any]) -> list:
     """Translate canonical filter dict into a list of SQLAlchemy conditions."""
     triples = normalize_filter(filter_dict)
-    triples = strip_unsupported_fields(triples, _PG_SUPPORTED_FIELDS, _PG_FIELD_ALIASES)
+    triples = strip_unsupported_fields(triples, _PG_SUPPORTED_FIELDS)
 
     conditions = []
     for field, op, value in triples:
@@ -312,65 +309,6 @@ class PgVectorDatabase(VectorDatabase):
                 self.ap.logger.error(f'Error deleting from pgvector by filter: {e}')
                 raise
 
-    async def list_by_filter(
-        self,
-        collection: str,
-        filter: dict[str, Any] | None = None,
-        limit: int = 20,
-        offset: int = 0,
-    ) -> tuple[list[dict[str, Any]], int]:
-        await self.get_or_create_collection(collection)
-
-        async with self.AsyncSessionLocal() as session:
-            try:
-                from sqlalchemy import select, func
-
-                stmt = (
-                    select(
-                        PgVectorEntry.id,
-                        PgVectorEntry.text,
-                        PgVectorEntry.file_id,
-                        PgVectorEntry.chunk_uuid,
-                    )
-                    .filter(PgVectorEntry.collection == collection)
-                    .offset(offset)
-                    .limit(limit)
-                )
-
-                count_stmt = (
-                    select(func.count()).select_from(PgVectorEntry).filter(PgVectorEntry.collection == collection)
-                )
-
-                if filter:
-                    for cond in _build_pg_conditions(filter):
-                        stmt = stmt.filter(cond)
-                        count_stmt = count_stmt.filter(cond)
-
-                result = await session.execute(stmt)
-                rows = result.fetchall()
-
-                count_result = await session.execute(count_stmt)
-                total = count_result.scalar() or 0
-
-                items = []
-                for row in rows:
-                    items.append(
-                        {
-                            'id': row.id,
-                            'document': row.text or '',
-                            'metadata': {
-                                'text': row.text or '',
-                                'file_id': row.file_id or '',
-                                'uuid': row.chunk_uuid or '',
-                            },
-                        }
-                    )
-
-                return items, total
-            except Exception as e:
-                self.ap.logger.error(f'Error listing from pgvector: {e}')
-                raise
-
     async def delete_collection(self, collection: str):
         """Delete all vectors in a collection
 

src/langbot/pkg/vector/vdbs/qdrant.py

@@ -150,97 +150,6 @@ class QdrantVectorDatabase(VectorDatabase):
         self.ap.logger.info(f"Deleted embeddings from Qdrant collection '{collection}' by filter")
         return 0  # Qdrant delete does not return a count
 
-    async def list_by_filter(
-        self,
-        collection: str,
-        filter: dict[str, Any] | None = None,
-        limit: int = 20,
-        offset: int = 0,
-    ) -> tuple[list[dict[str, Any]], int]:
-        exists = await self.client.collection_exists(collection)
-        if not exists:
-            return [], 0
-
-        qdrant_filter = _build_qdrant_filter(filter) if filter else None
-
-        # Qdrant scroll uses cursor-based pagination (offset = point ID),
-        # not numeric skip.  To support numeric offset we scroll through
-        # `offset + limit` items and discard the first `offset`.
-        remaining_to_skip = offset
-        remaining_to_collect = limit
-        cursor: int | str | None = None
-        collected: list[dict[str, Any]] = []
-
-        while remaining_to_skip > 0 or remaining_to_collect > 0:
-            batch_size = remaining_to_skip + remaining_to_collect if remaining_to_skip > 0 else remaining_to_collect
-            scroll_kwargs: dict[str, Any] = dict(
-                collection_name=collection,
-                limit=min(batch_size, 256),
-                with_payload=True if remaining_to_skip == 0 else False,
-                with_vectors=False,
-            )
-            if qdrant_filter:
-                scroll_kwargs['scroll_filter'] = qdrant_filter
-            if cursor is not None:
-                scroll_kwargs['offset'] = cursor
-
-            points, next_cursor = await self.client.scroll(**scroll_kwargs)
-            if not points:
-                break
-
-            for point in points:
-                if remaining_to_skip > 0:
-                    remaining_to_skip -= 1
-                    continue
-                if remaining_to_collect <= 0:
-                    break
-                # Re-fetch payload if we skipped it during the skip phase
-                payload = point.payload or {}
-                collected.append(
-                    {
-                        'id': str(point.id),
-                        'document': payload.get('text') or payload.get('document'),
-                        'metadata': payload,
-                    }
-                )
-                remaining_to_collect -= 1
-
-            if next_cursor is None:
-                break
-            cursor = next_cursor
-
-        # If we skipped without payload, re-fetch the collected items' payloads
-        # (only needed when offset > 0 and items were collected in a skip batch)
-        if offset > 0 and collected:
-            refetch_ids = [item['id'] for item in collected if not item.get('metadata')]
-            if refetch_ids:
-                fetched_points = await self.client.retrieve(
-                    collection_name=collection,
-                    ids=refetch_ids,
-                    with_payload=True,
-                    with_vectors=False,
-                )
-                payload_map = {str(p.id): p.payload or {} for p in fetched_points}
-                for item in collected:
-                    if item['id'] in payload_map:
-                        payload = payload_map[item['id']]
-                        item['metadata'] = payload
-                        item['document'] = payload.get('text') or payload.get('document')
-
-        # Use count() for accurate total (supports filter)
-        total = -1
-        try:
-            count_result = await self.client.count(
-                collection_name=collection,
-                count_filter=qdrant_filter,
-                exact=True,
-            )
-            total = count_result.count
-        except Exception:
-            pass
-
-        return collected, total
-
     async def delete_collection(self, collection: str):
         try:
             await self.client.delete_collection(collection)

src/langbot/pkg/vector/vdbs/seekdb.py

@@ -340,50 +340,6 @@ class SeekDBVectorDatabase(VectorDatabase):
         self.ap.logger.info(f"Deleted embeddings from SeekDB collection '{collection}' by filter")
         return 0  # SeekDB delete does not return a count
 
-    async def list_by_filter(
-        self,
-        collection: str,
-        filter: Dict[str, Any] | None = None,
-        limit: int = 20,
-        offset: int = 0,
-    ) -> tuple[list[Dict[str, Any]], int]:
-        exists = await asyncio.to_thread(self.client.has_collection, collection)
-        if not exists:
-            return [], 0
-
-        if collection not in self._collections:
-            coll = await asyncio.to_thread(self.client.get_collection, collection, embedding_function=None)
-            self._collections[collection] = coll
-        else:
-            coll = self._collections[collection]
-
-        get_kwargs: Dict[str, Any] = dict(
-            include=['metadatas', 'documents'],
-            limit=limit,
-            offset=offset,
-        )
-        if filter:
-            get_kwargs['where'] = filter
-
-        results = await asyncio.to_thread(coll.get, **get_kwargs)
-
-        ids = results.get('ids', [])
-        metadatas = results.get('metadatas', []) or [None] * len(ids)
-        documents = results.get('documents', []) or [None] * len(ids)
-
-        items = []
-        for i, vid in enumerate(ids):
-            items.append(
-                {
-                    'id': vid,
-                    'document': documents[i] if i < len(documents) else None,
-                    'metadata': metadatas[i] if i < len(metadatas) else {},
-                }
-            )
-
-        total = await asyncio.to_thread(coll.count) if not filter else -1
-        return items, total
-
     async def delete_collection(self, collection: str):
         """Delete the entire collection.
 

src/langbot/templates/config.yaml

@@ -2,7 +2,6 @@ admins: []
 api:
     port: 5300
     webhook_prefix: 'http://127.0.0.1:5300'
-    extra_webhook_prefix: ''
 command:
     enable: true
     prefix:
@@ -16,7 +15,6 @@ proxy:
     http: ''
     https: ''
 system:
-    instance_id: ''
     edition: community
     recovery_key: ''
     allow_modify_login_info: true

src/langbot/templates/default-pipeline-config.json

@@ -41,10 +41,7 @@
             "runner": "local-agent"
         },
         "local-agent": {
-            "model": {
-                "primary": "",
-                "fallbacks": []
-            },
+            "model": "",
             "max-round": 10,
             "prompt": [
                 {

src/langbot/templates/metadata/sensitive-words.json

@@ -2,5 +2,77 @@
     "说明": "mask将替换敏感词中的每一个字，若mask_word值不为空，则将敏感词整个替换为mask_word的值",
     "mask": "*",
     "mask_word": "",
-    "words": []
+    "words": [
+        "习近平",
+        "胡锦涛",
+        "江泽民",
+        "温家宝",
+        "李克强",
+        "李长春",
+        "毛泽东",
+        "邓小平",
+        "周恩来",
+        "马克思",
+        "社会主义",
+        "共产党",
+        "共产主义",
+        "大陆官方",
+        "北京政权",
+        "中华帝国",
+        "中国政府",
+        "共狗",
+        "六四事件",
+        "天安门",
+        "六四",
+        "政治局常委",
+        "两会",
+        "共青团",
+        "学潮",
+        "八九",
+        "二十大",
+        "民进党",
+        "台独",
+        "台湾独立",
+        "台湾国",
+        "国民党",
+        "台湾民国",
+        "中华民国",
+        "pornhub",
+        "Pornhub",
+        "[Yy]ou[Pp]orn",
+        "porn",
+        "Porn",
+        "[Xx][Vv]ideos",
+        "[Rr]ed[Tt]ube",
+        "[Xx][Hh]amster",
+        "[Ss]pank[Ww]ire",
+        "[Ss]pank[Bb]ang",
+        "[Tt]ube8",
+        "[Yy]ou[Jj]izz",
+        "[Bb]razzers",
+        "[Nn]aughty[ ]?[Aa]merica",
+        "作爱",
+        "做爱",
+        "性交",
+        "性爱",
+        "自慰",
+        "阴茎",
+        "淫妇",
+        "肛交",
+        "交配",
+        "性关系",
+        "性活动",
+        "色情",
+        "色图",
+        "涩图",
+        "裸体",
+        "小穴",
+        "淫荡",
+        "性爱",
+        "翻墙",
+        "VPN",
+        "科学上网",
+        "挂梯子",
+        "GFW"
+    ]
 }

tests/unit_tests/config/test_webhook_display_prefix.py

@@ -91,15 +91,14 @@ class TestWebhookDisplayPrefix:
 
     def test_default_webhook_prefix(self):
         """Test that the default webhook display prefix is correctly set"""
-        cfg = {'api': {'port': 5300, 'webhook_prefix': 'http://127.0.0.1:5300', 'extra_webhook_prefix': ''}}
+        cfg = {'api': {'port': 5300, 'webhook_prefix': 'http://127.0.0.1:5300'}}
 
         # Should have the default value
         assert cfg['api']['webhook_prefix'] == 'http://127.0.0.1:5300'
-        assert cfg['api']['extra_webhook_prefix'] == ''
 
     def test_webhook_prefix_env_override(self):
         """Test overriding webhook_prefix via environment variable"""
-        cfg = {'api': {'port': 5300, 'webhook_prefix': 'http://127.0.0.1:5300', 'extra_webhook_prefix': ''}}
+        cfg = {'api': {'port': 5300, 'webhook_prefix': 'http://127.0.0.1:5300'}}
 
         # Set environment variable
         os.environ['API__WEBHOOK_PREFIX'] = 'https://example.com:8080'
@@ -113,7 +112,7 @@ class TestWebhookDisplayPrefix:
 
     def test_webhook_prefix_with_custom_domain(self):
         """Test webhook_prefix with custom domain"""
-        cfg = {'api': {'port': 5300, 'webhook_prefix': 'http://127.0.0.1:5300', 'extra_webhook_prefix': ''}}
+        cfg = {'api': {'port': 5300, 'webhook_prefix': 'http://127.0.0.1:5300'}}
 
         # Set to a custom domain
         os.environ['API__WEBHOOK_PREFIX'] = 'https://bot.mycompany.com'
@@ -127,7 +126,7 @@ class TestWebhookDisplayPrefix:
 
     def test_webhook_prefix_with_subdirectory(self):
         """Test webhook_prefix with subdirectory path"""
-        cfg = {'api': {'port': 5300, 'webhook_prefix': 'http://127.0.0.1:5300', 'extra_webhook_prefix': ''}}
+        cfg = {'api': {'port': 5300, 'webhook_prefix': 'http://127.0.0.1:5300'}}
 
         # Set to a URL with subdirectory
         os.environ['API__WEBHOOK_PREFIX'] = 'https://example.com/langbot'
@@ -139,37 +138,6 @@ class TestWebhookDisplayPrefix:
         # Cleanup
         del os.environ['API__WEBHOOK_PREFIX']
 
-    def test_extra_webhook_prefix_default_empty(self):
-        """Test that extra_webhook_prefix defaults to empty string"""
-        cfg = {'api': {'port': 5300, 'webhook_prefix': 'http://127.0.0.1:5300', 'extra_webhook_prefix': ''}}
-
-        bot_uuid = 'test-bot-uuid'
-        webhook_prefix = cfg['api'].get('webhook_prefix', 'http://127.0.0.1:5300')
-        extra_webhook_prefix = cfg['api'].get('extra_webhook_prefix', '')
-        webhook_url = f'/bots/{bot_uuid}'
-
-        assert f'{webhook_prefix}{webhook_url}' == 'http://127.0.0.1:5300/bots/test-bot-uuid'
-        # extra should be empty when not configured
-        assert extra_webhook_prefix == ''
-
-    def test_extra_webhook_prefix_env_override(self):
-        """Test overriding extra_webhook_prefix via environment variable"""
-        cfg = {'api': {'port': 5300, 'webhook_prefix': 'http://127.0.0.1:5300', 'extra_webhook_prefix': ''}}
-
-        os.environ['API__EXTRA_WEBHOOK_PREFIX'] = 'https://extra.example.com'
-
-        result = _apply_env_overrides_to_config(cfg)
-
-        assert result['api']['extra_webhook_prefix'] == 'https://extra.example.com'
-
-        bot_uuid = 'test-bot-uuid'
-        extra_prefix = result['api']['extra_webhook_prefix']
-        webhook_url = f'/bots/{bot_uuid}'
-        assert f'{extra_prefix}{webhook_url}' == 'https://extra.example.com/bots/test-bot-uuid'
-
-        # Cleanup
-        del os.environ['API__EXTRA_WEBHOOK_PREFIX']
-
 
 if __name__ == '__main__':
     pytest.main([__file__, '-v'])

tests/unit_tests/pipeline/conftest.py

@@ -194,7 +194,7 @@ def sample_query(sample_message_chain, sample_message_event, mock_adapter):
         pipeline_config={
             'ai': {
                 'runner': {'runner': 'local-agent'},
-                'local-agent': {'model': {'primary': 'test-model-uuid', 'fallbacks': []}, 'prompt': 'test-prompt'},
+                'local-agent': {'model': 'test-model-uuid', 'prompt': 'test-prompt'},
             },
             'output': {'misc': {'at-sender': False, 'quote-origin': False}},
             'trigger': {'misc': {'combine-quote-message': False}},
@@ -219,7 +219,7 @@ def sample_pipeline_config():
     return {
         'ai': {
             'runner': {'runner': 'local-agent'},
-            'local-agent': {'model': {'primary': 'test-model-uuid', 'fallbacks': []}, 'prompt': 'test-prompt'},
+            'local-agent': {'model': 'test-model-uuid', 'prompt': 'test-prompt'},
         },
         'output': {'misc': {'at-sender': False, 'quote-origin': False}},
         'trigger': {'misc': {'combine-quote-message': False}},

web/package.json

@@ -102,10 +102,5 @@
     "typescript": "^5.8.3",
     "typescript-eslint": "^8.31.1"
   },
-  "packageManager": "pnpm@8.9.2+sha512.b9d35fe91b2a5854dadc43034a3e7b2e675fa4b56e20e8e09ef078fa553c18f8aed44051e7b36e8b8dd435f97eb0c44c4ff3b44fc7c6fa7d21e1fac17bbe661e",
-  "pnpm": {
-    "overrides": {
-      "minimatch": "3.1.3"
-    }
-  }
-}
+  "packageManager": "pnpm@8.9.2+sha512.b9d35fe91b2a5854dadc43034a3e7b2e675fa4b56e20e8e09ef078fa553c18f8aed44051e7b36e8b8dd435f97eb0c44c4ff3b44fc7c6fa7d21e1fac17bbe661e"
+}

web/pnpm-lock.yaml

@@ -4,9 +4,6 @@ settings:
   autoInstallPeers: true
   excludeLinksFromLockfile: false
 
-overrides:
-  minimatch: 3.1.3
-
 dependencies:
   '@dnd-kit/core':
     specifier: ^6.3.1
@@ -348,7 +345,7 @@ packages:
     dependencies:
       '@eslint/object-schema': 2.1.7
       debug: 4.4.3
-      minimatch: 3.1.3
+      minimatch: 3.1.2
     transitivePeerDependencies:
       - supports-color
     dev: true
@@ -378,7 +375,7 @@ packages:
       ignore: 5.3.2
       import-fresh: 3.3.1
       js-yaml: 4.1.1
-      minimatch: 3.1.3
+      minimatch: 3.1.2
       strip-json-comments: 3.1.1
     transitivePeerDependencies:
       - supports-color
@@ -2263,7 +2260,7 @@ packages:
       '@typescript-eslint/types': 8.54.0
       '@typescript-eslint/visitor-keys': 8.54.0
       debug: 4.4.3
-      minimatch: 3.1.3
+      minimatch: 9.0.5
       semver: 7.7.3
       tinyglobby: 0.2.15
       ts-api-utils: 2.4.0(typescript@5.9.3)
@@ -2681,6 +2678,12 @@ packages:
       concat-map: 0.0.1
     dev: true
 
+  /brace-expansion@2.0.2:
+    resolution: {integrity: sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==}
+    dependencies:
+      balanced-match: 1.0.2
+    dev: true
+
   /braces@3.0.3:
     resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==}
     engines: {node: '>=8'}
@@ -3342,7 +3345,7 @@ packages:
       hasown: 2.0.2
       is-core-module: 2.16.1
       is-glob: 4.0.3
-      minimatch: 3.1.3
+      minimatch: 3.1.2
       object.fromentries: 2.0.8
       object.groupby: 1.0.3
       object.values: 1.2.1
@@ -3373,7 +3376,7 @@ packages:
       hasown: 2.0.2
       jsx-ast-utils: 3.3.5
       language-tags: 1.0.9
-      minimatch: 3.1.3
+      minimatch: 3.1.2
       object.fromentries: 2.0.8
       safe-regex-test: 1.1.0
       string.prototype.includes: 2.0.1
@@ -3425,7 +3428,7 @@ packages:
       estraverse: 5.3.0
       hasown: 2.0.2
       jsx-ast-utils: 3.3.5
-      minimatch: 3.1.3
+      minimatch: 3.1.2
       object.entries: 1.1.9
       object.fromentries: 2.0.8
       object.values: 1.2.1
@@ -3495,7 +3498,7 @@ packages:
       is-glob: 4.0.3
       json-stable-stringify-without-jsonify: 1.0.1
       lodash.merge: 4.6.2
-      minimatch: 3.1.3
+      minimatch: 3.1.2
       natural-compare: 1.4.0
       optionator: 0.9.4
     transitivePeerDependencies:
@@ -5110,12 +5113,19 @@ packages:
     engines: {node: '>=18'}
     dev: true
 
-  /minimatch@3.1.3:
-    resolution: {integrity: sha512-M2GCs7Vk83NxkUyQV1bkABc4yxgz9kILhHImZiBPAZ9ybuvCb0/H7lEl5XvIg3g+9d4eNotkZA5IWwYl0tibaA==}
+  /minimatch@3.1.2:
+    resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==}
     dependencies:
       brace-expansion: 1.1.12
     dev: true
 
+  /minimatch@9.0.5:
+    resolution: {integrity: sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==}
+    engines: {node: '>=16 || 14 >=14.17'}
+    dependencies:
+      brace-expansion: 2.0.2
+    dev: true
+
   /minimist@1.2.8:
     resolution: {integrity: sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==}
     dev: true

web/src/app/home/bots/components/bot-form/BotForm.tsx

@@ -1,4 +1,4 @@
-import React, { useEffect, useMemo, useState } from 'react';
+import React, { useEffect, useState } from 'react';
 import {
   IChooseAdapterEntity,
   IPipelineEntity,
@@ -113,73 +113,109 @@ export default function BotForm({
   const [dynamicFormConfigList, setDynamicFormConfigList] = useState<
     IDynamicFormItemSchema[]
   >([]);
+  const [filteredDynamicFormConfigList, setFilteredDynamicFormConfigList] =
+    useState<IDynamicFormItemSchema[]>([]);
   const [, setIsLoading] = useState<boolean>(false);
   const [webhookUrl, setWebhookUrl] = useState<string>('');
-  const [extraWebhookUrl, setExtraWebhookUrl] = useState<string>('');
+  const webhookInputRef = React.useRef<HTMLInputElement>(null);
   const [copied, setCopied] = useState<boolean>(false);
-  const [extraCopied, setExtraCopied] = useState<boolean>(false);
 
   // Watch adapter and adapter_config for filtering
   const currentAdapter = form.watch('adapter');
   const currentAdapterConfig = form.watch('adapter_config');
 
-  // Derive the filtered config list via useMemo instead of useEffect+setState
-  // to avoid creating new array references that would cause DynamicFormComponent
-  // to re-subscribe its form.watch, re-emit values, and trigger an infinite loop.
-  // Only depend on the specific field we care about (enable-webhook) rather than
-  // the entire currentAdapterConfig object, which changes on every emission.
-  const enableWebhook = currentAdapterConfig?.['enable-webhook'];
-  const filteredDynamicFormConfigList = useMemo(() => {
-    if (currentAdapter === 'lark' && enableWebhook === false) {
-      // Hide encrypt-key field when webhook is disabled
-      return dynamicFormConfigList.filter(
-        (config) => config.name !== 'encrypt-key',
-      );
-    }
-    // For non-Lark adapters or when webhook is enabled/undefined, show all fields
-    return dynamicFormConfigList;
-  }, [currentAdapter, enableWebhook, dynamicFormConfigList]);
-
   useEffect(() => {
     setBotFormValues();
   }, []);
 
-  // 复制到剪贴板的辅助函数
-  const copyToClipboard = (
-    text: string,
-    setStatus: React.Dispatch<React.SetStateAction<boolean>>,
-  ) => {
-    if (navigator.clipboard && navigator.clipboard.writeText) {
-      navigator.clipboard
-        .writeText(text)
-        .then(() => {
-          setStatus(true);
-          setTimeout(() => setStatus(false), 2000);
-        })
-        .catch(() => {
-          // 降级：创建临时textarea复制
-          fallbackCopy(text, setStatus);
-        });
+  // Filter dynamic form config list based on enable-webhook status for Lark adapter
+  useEffect(() => {
+    if (currentAdapter === 'lark') {
+      const enableWebhook = currentAdapterConfig?.['enable-webhook'];
+      if (enableWebhook === false) {
+        // Hide encrypt-key field when webhook is disabled
+        setFilteredDynamicFormConfigList(
+          dynamicFormConfigList.filter(
+            (config) => config.name !== 'encrypt-key',
+          ),
+        );
+      } else {
+        // Show all fields when webhook is enabled or undefined
+        setFilteredDynamicFormConfigList(dynamicFormConfigList);
+      }
     } else {
-      fallbackCopy(text, setStatus);
+      // For non-Lark adapters, show all fields
+      setFilteredDynamicFormConfigList(dynamicFormConfigList);
     }
-  };
+  }, [currentAdapter, currentAdapterConfig, dynamicFormConfigList]);
 
-  const fallbackCopy = (
-    text: string,
-    setStatus: React.Dispatch<React.SetStateAction<boolean>>,
-  ) => {
-    const textarea = document.createElement('textarea');
-    textarea.value = text;
-    textarea.style.position = 'fixed';
-    textarea.style.opacity = '0';
-    document.body.appendChild(textarea);
-    textarea.select();
-    const successful = document.execCommand('copy');
-    document.body.removeChild(textarea);
-    if (successful) {
-      setStatus(true);
-      setTimeout(() => setStatus(false), 2000);
+  // 复制到剪贴板的辅助函数 - 使用页面上的真实input元素
+  const copyToClipboard = () => {
+    console.log('[Copy] Attempting to copy from input element');
+
+    const inputElement = webhookInputRef.current;
+    if (!inputElement) {
+      console.error('[Copy] Input element not found');
+      return;
+    }
+
+    try {
+      // 确保input元素可见且未被禁用
+      inputElement.disabled = false;
+      inputElement.readOnly = false;
+
+      // 聚焦并选中所有文本
+      inputElement.focus();
+      inputElement.select();
+
+      // 尝试使用现代API
+      if (navigator.clipboard && navigator.clipboard.writeText) {
+        console.log(
+          '[Copy] Using Clipboard API with input value:',
+          inputElement.value,
+        );
+        navigator.clipboard
+          .writeText(inputElement.value)
+          .then(() => {
+            console.log('[Copy] Clipboard API success');
+            inputElement.blur(); // 取消选中
+            inputElement.readOnly = true;
+            setCopied(true);
+            setTimeout(() => setCopied(false), 2000);
+          })
+          .catch((err) => {
+            console.error(
+              '[Copy] Clipboard API failed, trying execCommand:',
+              err,
+            );
+            // 降级到execCommand
+            const successful = document.execCommand('copy');
+            console.log('[Copy] execCommand result:', successful);
+            inputElement.blur();
+            inputElement.readOnly = true;
+            if (successful) {
+              setCopied(true);
+              setTimeout(() => setCopied(false), 2000);
+            }
+          });
+      } else {
+        // 直接使用execCommand
+        console.log(
+          '[Copy] Using execCommand with input value:',
+          inputElement.value,
+        );
+        const successful = document.execCommand('copy');
+        console.log('[Copy] execCommand result:', successful);
+        inputElement.blur();
+        inputElement.readOnly = true;
+        if (successful) {
+          setCopied(true);
+          setTimeout(() => setCopied(false), 2000);
+        }
+      }
+    } catch (err) {
+      console.error('[Copy] Copy failed:', err);
+      inputElement.readOnly = true;
     }
   };
 
@@ -204,7 +240,6 @@ export default function BotForm({
             } else {
               setWebhookUrl('');
             }
-            setExtraWebhookUrl(val.extra_webhook_full_url || '');
           })
           .catch((err) => {
             toast.error(
@@ -214,7 +249,6 @@ export default function BotForm({
       } else {
         form.reset();
         setWebhookUrl('');
-        setExtraWebhookUrl('');
       }
     });
   }
@@ -287,20 +321,14 @@ export default function BotForm({
     setAdapterNameToDynamicConfigMap(adapterNameToDynamicConfigMap);
   }
 
-  async function getBotConfig(botId: string): Promise<
-    z.infer<typeof formSchema> & {
-      webhook_full_url?: string;
-      extra_webhook_full_url?: string;
-    }
-  > {
+  async function getBotConfig(
+    botId: string,
+  ): Promise<z.infer<typeof formSchema> & { webhook_full_url?: string }> {
     return new Promise((resolve, reject) => {
       httpClient
         .getBot(botId)
         .then((res) => {
           const bot = res.bot;
-          const runtimeValues = bot.adapter_runtime_values as
-            | Record<string, unknown>
-            | undefined;
           resolve({
             adapter: bot.adapter,
             description: bot.description,
@@ -308,12 +336,10 @@ export default function BotForm({
             adapter_config: bot.adapter_config,
             enable: bot.enable ?? true,
             use_pipeline_uuid: bot.use_pipeline_uuid ?? '',
-            webhook_full_url: runtimeValues?.webhook_full_url as
-              | string
-              | undefined,
-            extra_webhook_full_url: runtimeValues?.extra_webhook_full_url as
-              | string
-              | undefined,
+            webhook_full_url: bot.adapter_runtime_values
+              ? ((bot.adapter_runtime_values as Record<string, unknown>)
+                  .webhook_full_url as string)
+              : undefined,
           });
         })
         .catch((err) => {
@@ -504,11 +530,13 @@ export default function BotForm({
 
                 {/* Webhook 地址显示（统一 Webhook 模式） */}
                 {webhookUrl &&
-                  (currentAdapter !== 'lark' || enableWebhook !== false) && (
+                  (currentAdapter !== 'lark' ||
+                    currentAdapterConfig?.['enable-webhook'] !== false) && (
                     <FormItem>
                       <FormLabel>{t('bots.webhookUrl')}</FormLabel>
                       <div className="flex items-center gap-2">
                         <Input
+                          ref={webhookInputRef}
                           value={webhookUrl}
                           readOnly
                           className="flex-1 bg-gray-50 dark:bg-gray-900"
@@ -521,7 +549,7 @@ export default function BotForm({
                           type="button"
                           variant="outline"
                           size="sm"
-                          onClick={() => copyToClipboard(webhookUrl, setCopied)}
+                          onClick={copyToClipboard}
                         >
                           {copied ? (
                             <Check className="h-4 w-4 text-green-600 mr-2" />
@@ -531,37 +559,8 @@ export default function BotForm({
                           {t('common.copy')}
                         </Button>
                       </div>
-                      {extraWebhookUrl && (
-                        <div className="flex items-center gap-2 mt-2">
-                          <Input
-                            value={extraWebhookUrl}
-                            readOnly
-                            className="flex-1 bg-gray-50 dark:bg-gray-900"
-                            onClick={(e) => {
-                              (e.target as HTMLInputElement).select();
-                            }}
-                          />
-                          <Button
-                            type="button"
-                            variant="outline"
-                            size="sm"
-                            onClick={() =>
-                              copyToClipboard(extraWebhookUrl, setExtraCopied)
-                            }
-                          >
-                            {extraCopied ? (
-                              <Check className="h-4 w-4 text-green-600 mr-2" />
-                            ) : (
-                              <Copy className="h-4 w-4 mr-2" />
-                            )}
-                            {t('common.copy')}
-                          </Button>
-                        </div>
-                      )}
                       <p className="text-sm text-gray-500 mt-1">
-                        {extraWebhookUrl
-                          ? t('bots.webhookUrlHintEither')
-                          : t('bots.webhookUrlHint')}
+                        {t('bots.webhookUrlHint')}
                       </p>
                     </FormItem>
                   )}
@@ -668,7 +667,7 @@ export default function BotForm({
                 </div>
                 <DynamicFormComponent
                   itemConfigList={filteredDynamicFormConfigList}
-                  initialValues={currentAdapterConfig}
+                  initialValues={form.watch('adapter_config')}
                   onSubmit={(values) => {
                     form.setValue('adapter_config', values);
                   }}

web/src/app/home/components/dynamic-form/DynamicFormComponent.tsx

@@ -34,35 +34,6 @@ export default function DynamicFormComponent({
   const previousInitialValues = useRef(initialValues);
   const { t } = useTranslation();
 
-  // Normalize a form value according to its field type.
-  // This ensures legacy/malformed data (e.g. a plain string for
-  // model-fallback-selector) is coerced to the expected shape
-  // so that downstream components never crash.
-  const normalizeFieldValue = (
-    item: IDynamicFormItemSchema,
-    value: unknown,
-  ): unknown => {
-    if (item.type === 'model-fallback-selector') {
-      if (value != null && typeof value === 'object' && !Array.isArray(value)) {
-        const obj = value as Record<string, unknown>;
-        return {
-          primary: typeof obj.primary === 'string' ? obj.primary : '',
-          fallbacks: Array.isArray(obj.fallbacks)
-            ? (obj.fallbacks as unknown[]).filter(
-                (v): v is string => typeof v === 'string',
-              )
-            : [],
-        };
-      }
-      // Legacy string format or any other unexpected type
-      return {
-        primary: typeof value === 'string' ? value : '',
-        fallbacks: [],
-      };
-    }
-    return value;
-  };
-
   // 根据 itemConfigList 动态生成 zod schema
   const formSchema = z.object(
     itemConfigList.reduce(
@@ -145,10 +116,10 @@ export default function DynamicFormComponent({
     resolver: zodResolver(formSchema),
     defaultValues: itemConfigList.reduce((acc, item) => {
       // 优先使用 initialValues，如果没有则使用默认值
-      const rawValue = initialValues?.[item.name] ?? item.default;
+      const value = initialValues?.[item.name] ?? item.default;
       return {
         ...acc,
-        [item.name]: normalizeFieldValue(item, rawValue),
+        [item.name]: value,
       };
     }, {} as FormValues),
   });
@@ -173,8 +144,7 @@ export default function DynamicFormComponent({
       // 合并默认值和初始值
       const mergedValues = itemConfigList.reduce(
         (acc, item) => {
-          const rawValue = initialValues[item.name] ?? item.default;
-          acc[item.name] = normalizeFieldValue(item, rawValue) as object;
+          acc[item.name] = initialValues[item.name] ?? item.default;
           return acc;
         },
         {} as Record<string, object>,
@@ -211,15 +181,6 @@ export default function DynamicFormComponent({
     );
     onSubmitRef.current?.(initialFinalValues);
 
-    // Update previousInitialValues to the emitted snapshot so that if the
-    // parent writes these values back as new initialValues, the deep
-    // comparison in the initialValues-sync useEffect won't detect a change
-    // and won't trigger an infinite update loop.
-    previousInitialValues.current = initialFinalValues as Record<
-      string,
-      object
-    >;
-
     const subscription = form.watch(() => {
       const formValues = form.getValues();
       const finalValues = itemConfigList.reduce(
@@ -230,7 +191,6 @@ export default function DynamicFormComponent({
         {} as Record<string, object>,
       );
       onSubmitRef.current?.(finalValues);
-      previousInitialValues.current = finalValues as Record<string, object>;
     });
     return () => subscription.unsubscribe();
   }, [form, itemConfigList]);

web/src/app/home/components/dynamic-form/DynamicFormItemComponent.tsx

@@ -348,31 +348,10 @@ export default function DynamicFormItemComponent({
         {} as Record<string, LLMModel[]>,
       );
 
-      const rawModelValue = field.value;
-      const modelValue: { primary: string; fallbacks: string[] } =
-        rawModelValue != null &&
-        typeof rawModelValue === 'object' &&
-        !Array.isArray(rawModelValue)
-          ? {
-              primary:
-                typeof (rawModelValue as Record<string, unknown>).primary ===
-                'string'
-                  ? ((rawModelValue as Record<string, unknown>)
-                      .primary as string)
-                  : '',
-              fallbacks: Array.isArray(
-                (rawModelValue as Record<string, unknown>).fallbacks,
-              )
-                ? (
-                    (rawModelValue as Record<string, unknown>)
-                      .fallbacks as unknown[]
-                  ).filter((v): v is string => typeof v === 'string')
-                : [],
-            }
-          : {
-              primary: typeof rawModelValue === 'string' ? rawModelValue : '',
-              fallbacks: [],
-            };
+      const modelValue = field.value as {
+        primary: string;
+        fallbacks: string[];
+      };
 
       const renderModelSelect = (
         value: string,

web/src/app/home/knowledge/components/kb-form/KBForm.tsx

@@ -1,4 +1,4 @@
-import { useEffect, useMemo, useState } from 'react';
+import { useEffect, useState } from 'react';
 import Link from 'next/link';
 import { useForm } from 'react-hook-form';
 import { zodResolver } from '@hookform/resolvers/zod';
@@ -242,17 +242,11 @@ export default function KBForm({
   };
 
   // Convert creation schema to dynamic form items (same as ExternalKBForm)
-  // Memoize to avoid regenerating UUIDs on every render, which would cause
-  // DynamicFormComponent's useEffect to re-fire and trigger an infinite loop.
-  const configFormItems = useMemo(
-    () => parseCreationSchema(selectedEngine?.creation_schema),
-    [selectedEngine?.creation_schema],
-  );
+  const configFormItems = parseCreationSchema(selectedEngine?.creation_schema);
 
   // Convert retrieval schema to dynamic form items
-  const retrievalFormItems = useMemo(
-    () => parseCreationSchema(selectedEngine?.retrieval_schema),
-    [selectedEngine?.retrieval_schema],
+  const retrievalFormItems = parseCreationSchema(
+    selectedEngine?.retrieval_schema,
   );
 
   // Show loading state

web/src/app/login/page.tsx

@@ -23,7 +23,7 @@ import {
 import { useEffect, useState } from 'react';
 import { httpClient, initializeUserInfo } from '@/app/infra/http';
 import { useRouter } from 'next/navigation';
-import { Mail, Lock, Loader2, AlertCircle, RefreshCw } from 'lucide-react';
+import { Mail, Lock, Loader2 } from 'lucide-react';
 import langbotIcon from '@/app/assets/langbot-logo.webp';
 import { toast } from 'sonner';
 import { useTranslation } from 'react-i18next';
@@ -46,8 +46,6 @@ export default function Login() {
   const [accountType, setAccountType] = useState<AccountType | null>(null);
   const [hasPassword, setHasPassword] = useState(false);
   const [loading, setLoading] = useState(true);
-  const [loadError, setLoadError] = useState<string | null>(null);
-  const [retrying, setRetrying] = useState(false);
 
   const form = useForm<z.infer<ReturnType<typeof formSchema>>>({
     resolver: zodResolver(formSchema(t)),
@@ -63,7 +61,6 @@ export default function Login() {
 
   async function checkAccountInfo() {
     try {
-      setLoadError(null);
       const res = await httpClient.getAccountInfo();
       if (!res.initialized) {
         router.push('/register');
@@ -75,22 +72,11 @@ export default function Login() {
 
       // Also check if already logged in
       checkIfAlreadyLoggedIn();
-    } catch (err) {
-      const errorMessage =
-        err instanceof Error ? err.message : t('common.loginLoadError');
-      setLoadError(errorMessage);
+    } catch {
       setLoading(false);
     }
   }
 
-  async function handleRetry() {
-    setRetrying(true);
-    setLoading(true);
-    setLoadError(null);
-    await checkAccountInfo();
-    setRetrying(false);
-  }
-
   function checkIfAlreadyLoggedIn() {
     httpClient
       .checkUserToken()
@@ -143,54 +129,6 @@ export default function Login() {
     );
   }
 
-  // Show error state when account info failed to load
-  if (loadError) {
-    return (
-      <div className="min-h-screen flex items-center justify-center bg-gray-50 dark:bg-neutral-900">
-        <Card className="w-[375px] shadow-lg dark:shadow-white/10">
-          <CardHeader>
-            <div className="flex justify-between items-center mb-6">
-              <ThemeToggle />
-              <LanguageSelector />
-            </div>
-            <img
-              src={langbotIcon.src}
-              alt="LangBot"
-              className="w-16 h-16 mb-4 mx-auto"
-            />
-            <CardTitle className="text-2xl text-center">
-              {t('common.welcome')}
-            </CardTitle>
-          </CardHeader>
-          <CardContent className="space-y-4">
-            <div className="flex flex-col items-center gap-3 py-4">
-              <AlertCircle className="h-10 w-10 text-destructive" />
-              <p className="text-sm text-center text-muted-foreground">
-                {t('common.loginLoadErrorDesc')}
-              </p>
-              <code className="text-xs bg-muted px-3 py-2 rounded max-w-full overflow-x-auto block text-center text-muted-foreground">
-                {loadError}
-              </code>
-              <Button
-                onClick={handleRetry}
-                disabled={retrying}
-                variant="outline"
-                className="mt-2 cursor-pointer"
-              >
-                {retrying ? (
-                  <Loader2 className="mr-2 h-4 w-4 animate-spin" />
-                ) : (
-                  <RefreshCw className="mr-2 h-4 w-4" />
-                )}
-                {t('common.retry')}
-              </Button>
-            </div>
-          </CardContent>
-        </Card>
-      </div>
-    );
-  }
-
   // Determine what to show based on account type
   const showLocalLogin =
     accountType === 'local' || (accountType === 'space' && hasPassword);

web/src/i18n/locales/en-US.ts

@@ -11,10 +11,6 @@ const enUS = {
     continueToLogin: 'Login to continue',
     loginSuccess: 'Login successful',
     loginFailed: 'Login failed, please check your email and password',
-    loginLoadError: 'Unable to connect to server',
-    loginLoadErrorDesc:
-      'Unable to connect to the LangBot backend. Please make sure the service is running and try again.',
-    retry: 'Retry',
     enterEmail: 'Enter email address',
     enterPassword: 'Enter password',
     invalidEmail: 'Please enter a valid email address',
@@ -288,8 +284,6 @@ const enUS = {
     webhookUrlCopied: 'Webhook URL copied',
     webhookUrlHint:
       'Click the input to select all, then press Ctrl+C (Mac: Cmd+C) to copy, or click the button',
-    webhookUrlHintEither:
-      'Use either of the two URLs above in your platform configuration',
     logLevel: 'Log Level',
     allLevels: 'All Levels',
     selectLevel: 'Select Level',

web/src/i18n/locales/ja-JP.ts

@@ -12,10 +12,6 @@
     loginSuccess: 'ログインに成功しました',
     loginFailed:
       'ログインに失敗しました。メールアドレスまたはパスワードをご確認ください',
-    loginLoadError: 'サーバーに接続できません',
-    loginLoadErrorDesc:
-      'LangBot バックエンドに接続できません。サービスが起動していることを確認してから再試行してください。',
-    retry: '再試行',
     enterEmail: 'メールアドレスを入力',
     enterPassword: 'パスワードを入力',
     invalidEmail: '有効なメールアドレスを入力してください',
@@ -293,8 +289,6 @@
     webhookUrlCopied: 'Webhook URL をコピーしました',
     webhookUrlHint:
       '入力ボックスをクリックして全選択し、Ctrl+C (Mac: Cmd+C) でコピーするか、右側のボタンをクリックしてください',
-    webhookUrlHintEither:
-      '上記の2つのURLのいずれかをプラットフォーム設定に使用してください',
     logLevel: 'ログレベル',
     allLevels: 'すべてのレベル',
     selectLevel: 'レベルを選択',

web/src/i18n/locales/zh-Hans.ts

@@ -11,9 +11,6 @@ const zhHans = {
     continueToLogin: '登录以继续',
     loginSuccess: '登录成功',
     loginFailed: '登录失败，请检查邮箱和密码是否正确',
-    loginLoadError: '无法连接到服务器',
-    loginLoadErrorDesc: '无法连接到 LangBot 后端服务，请确认服务已启动后重试。',
-    retry: '重试',
     enterEmail: '输入邮箱地址',
     enterPassword: '输入密码',
     invalidEmail: '请输入有效的邮箱地址',
@@ -276,7 +273,6 @@ const zhHans = {
     webhookUrlCopied: 'Webhook 地址已复制',
     webhookUrlHint:
       '点击输入框自动全选，然后按 Ctrl+C (Mac: Cmd+C) 复制，或点击右侧按钮',
-    webhookUrlHintEither: '以上两个地址任选其一填入平台配置即可',
     logLevel: '日志级别',
     allLevels: '全部级别',
     selectLevel: '选择级别',

web/src/i18n/locales/zh-Hant.ts

@@ -11,9 +11,6 @@ const zhHant = {
     continueToLogin: '登入以繼續',
     loginSuccess: '登入成功',
     loginFailed: '登入失敗，請檢查電子郵件和密碼是否正確',
-    loginLoadError: '無法連線到伺服器',
-    loginLoadErrorDesc: '無法連線到 LangBot 後端服務，請確認服務已啟動後重試。',
-    retry: '重試',
     enterEmail: '輸入電子郵件地址',
     enterPassword: '輸入密碼',
     invalidEmail: '請輸入有效的電子郵件地址',
@@ -275,7 +272,6 @@ const zhHant = {
     webhookUrlCopied: 'Webhook 位址已複製',
     webhookUrlHint:
       '點擊輸入框自動全選，然後按 Ctrl+C (Mac: Cmd+C) 複製，或點擊右側按鈕',
-    webhookUrlHintEither: '以上兩個地址任選其一填入平台配置即可',
     logLevel: '日誌級別',
     allLevels: '全部級別',
     selectLevel: '選擇級別',