feat(platform): add wecom eba adapters

tests/e2e/live_wecom_eba_probe.py

@@ -0,0 +1,214 @@
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+from quart import Quart, request
+
+from langbot.pkg.platform.adapters.wecom.adapter import WecomAdapter
+from langbot_plugin.api.definition.abstract.platform.event_logger import AbstractEventLogger
+from langbot_plugin.api.entities.builtin.platform import events as platform_events
+from langbot_plugin.api.entities.builtin.platform import message as platform_message
+
+
+TINY_PNG = (
+    'data:image/png;base64,'
+    'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+/p9sAAAAASUVORK5CYII='
+)
+
+
+class ProbeLogger(AbstractEventLogger):
+    async def info(self, text, images=None, message_session_id=None, no_throw=True):
+        print(f'[info] {text}')
+
+    async def debug(self, text, images=None, message_session_id=None, no_throw=True):
+        print(f'[debug] {text}')
+
+    async def warning(self, text, images=None, message_session_id=None, no_throw=True):
+        print(f'[warning] {text}')
+
+    async def error(self, text, images=None, message_session_id=None, no_throw=True):
+        print(f'[error] {text}')
+
+
+def redact(value: Any) -> Any:
+    if isinstance(value, dict):
+        redacted = {}
+        for key, item in value.items():
+            if key.lower() in {'secret', 'token', 'encodingaeskey', 'access_token'}:
+                redacted[key] = '<redacted>'
+            else:
+                redacted[key] = redact(item)
+        return redacted
+    if isinstance(value, list):
+        return [redact(item) for item in value]
+    return value
+
+
+def summarize_event(event: platform_events.EBAEvent) -> dict:
+    data = {
+        'type': event.type,
+        'adapter_name': event.adapter_name,
+        'timestamp': event.timestamp,
+    }
+    for field in ('message_id', 'chat_id', 'chat_type', 'action', 'data'):
+        if hasattr(event, field):
+            value = getattr(event, field)
+            if hasattr(value, 'value'):
+                value = value.value
+            data[field] = redact(value)
+    if hasattr(event, 'sender') and event.sender is not None:
+        data['sender'] = event.sender.model_dump()
+    if hasattr(event, 'message_chain') and event.message_chain is not None:
+        data['message_chain'] = event.message_chain.model_dump()
+    return data
+
+
+def record_api(results: list[dict[str, Any]], name: str, ok: bool, result: Any = None, error: Exception | None = None):
+    entry = {'name': name, 'ok': ok}
+    if result is not None:
+        entry['result'] = redact(result)
+    if error is not None:
+        entry['error'] = repr(error)
+    results.append(entry)
+    print('WECOM_EBA_API', json.dumps(entry, ensure_ascii=False, default=str))
+
+
+async def run_api(results: list[dict[str, Any]], name: str, func):
+    try:
+        result = await func()
+        record_api(results, name, True, result)
+        return result
+    except Exception as exc:
+        record_api(results, name, False, error=exc)
+        return None
+
+
+def config_from_env() -> dict:
+    required = {
+        'corpid': os.getenv('WECOM_CORPID', ''),
+        'secret': os.getenv('WECOM_SECRET', ''),
+        'token': os.getenv('WECOM_TOKEN', ''),
+        'EncodingAESKey': os.getenv('WECOM_ENCODING_AES_KEY', ''),
+    }
+    missing = [key for key, value in required.items() if not value]
+    if missing:
+        raise RuntimeError(f'Missing required WeCom env vars for fields: {missing}')
+    return {
+        **required,
+        'contacts_secret': os.getenv('WECOM_CONTACTS_SECRET', ''),
+        'api_base_url': os.getenv('WECOM_API_BASE_URL', 'https://qyapi.weixin.qq.com/cgi-bin'),
+    }
+
+
+async def run_probe(args: argparse.Namespace):
+    adapter = WecomAdapter(config_from_env(), ProbeLogger())
+    events: list[platform_events.EBAEvent] = []
+    api_results: list[dict[str, Any]] = []
+    first_message = asyncio.Event()
+    log_path = Path(args.log)
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+
+    async def listener(event, adapter):
+        events.append(event)
+        with log_path.open('a', encoding='utf-8') as fp:
+            fp.write(json.dumps(summarize_event(event), ensure_ascii=False, default=str) + '\n')
+        print('WECOM_EBA_EVENT', json.dumps(summarize_event(event), ensure_ascii=False, default=str))
+        if isinstance(event, platform_events.MessageReceivedEvent):
+            first_message.set()
+
+    adapter.register_listener(platform_events.EBAEvent, listener)
+
+    app = Quart(__name__)
+
+    @app.route(args.path, methods=['GET', 'POST'])
+    async def callback():
+        return await adapter.handle_unified_webhook(args.bot_uuid, '', request)
+
+    server_task = asyncio.create_task(app.run_task(host=args.host, port=args.port))
+    try:
+        print(f'READY: configure WeCom callback URL to http://{args.host}:{args.port}{args.path}')
+        print('READY: send a real WeCom application message to the bot now.')
+        await asyncio.wait_for(first_message.wait(), timeout=args.timeout)
+
+        source = next(event for event in events if isinstance(event, platform_events.MessageReceivedEvent))
+        raw_event = source.source_platform_object
+        target_id = f'{source.chat_id}|{raw_event.agent_id}'
+
+        if not args.skip_api:
+            await run_api(
+                api_results,
+                'reply_message:text',
+                lambda: adapter.reply_message(
+                    source,
+                    platform_message.MessageChain([platform_message.Plain(text='WeCom EBA probe reply')]),
+                ),
+            )
+            await run_api(
+                api_results,
+                'send_message:text',
+                lambda: adapter.send_message(
+                    'person',
+                    target_id,
+                    platform_message.MessageChain([platform_message.Plain(text='WeCom EBA probe send')]),
+                ),
+            )
+            await run_api(
+                api_results,
+                'send_message:image',
+                lambda: adapter.send_message(
+                    'person',
+                    target_id,
+                    platform_message.MessageChain(
+                        [
+                            platform_message.Plain(text='WeCom EBA probe image'),
+                            platform_message.Image(base64=TINY_PNG),
+                        ]
+                    ),
+                ),
+            )
+            await run_api(
+                api_results,
+                'get_message',
+                lambda: adapter.get_message('private', source.chat_id, source.message_id),
+            )
+            await run_api(api_results, 'get_user_info', lambda: adapter.get_user_info(source.sender.id))
+            await run_api(api_results, 'get_friend_list', lambda: adapter.get_friend_list())
+            await run_api(api_results, 'call_platform_api:check_access_token', lambda: adapter.call_platform_api('check_access_token', {}))
+            await run_api(
+                api_results,
+                'call_platform_api:get_user_info',
+                lambda: adapter.call_platform_api('get_user_info', {'user_id': source.sender.id}),
+            )
+
+        summary = {
+            'events': [event.type for event in events],
+            'api_results': api_results,
+            'log_path': str(log_path),
+        }
+        print('WECOM_EBA_SUMMARY', json.dumps(summary, ensure_ascii=False, default=str))
+        return summary
+    finally:
+        server_task.cancel()
+        await adapter.kill()
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Live WeCom EBA adapter probe.')
+    parser.add_argument('--host', default='0.0.0.0')
+    parser.add_argument('--port', type=int, default=5312)
+    parser.add_argument('--path', default='/wecom/callback')
+    parser.add_argument('--timeout', type=int, default=180)
+    parser.add_argument('--bot-uuid', default='wecom-eba-live-probe')
+    parser.add_argument('--log', default='data/temp/wecom_eba_live_probe.jsonl')
+    parser.add_argument('--skip-api', action='store_true')
+    args = parser.parse_args()
+    asyncio.run(run_probe(args))
+
+
+if __name__ == '__main__':
+    main()

tests/e2e/live_wecombot_eba_probe.py

@@ -0,0 +1,203 @@
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+from quart import Quart, request
+
+from langbot.pkg.platform.adapters.wecombot.adapter import WecomBotAdapter
+from langbot_plugin.api.definition.abstract.platform.event_logger import AbstractEventLogger
+from langbot_plugin.api.entities.builtin.platform import events as platform_events
+from langbot_plugin.api.entities.builtin.platform import message as platform_message
+
+
+class ProbeLogger(AbstractEventLogger):
+    async def info(self, text, images=None, message_session_id=None, no_throw=True):
+        print(f'[info] {text}')
+
+    async def debug(self, text, images=None, message_session_id=None, no_throw=True):
+        print(f'[debug] {text}')
+
+    async def warning(self, text, images=None, message_session_id=None, no_throw=True):
+        print(f'[warning] {text}')
+
+    async def error(self, text, images=None, message_session_id=None, no_throw=True):
+        print(f'[error] {text}')
+
+
+def redact(value: Any) -> Any:
+    if isinstance(value, dict):
+        return {
+            key: '<redacted>' if key.lower() in {'secret', 'token', 'encodingaeskey', 'encrypt', 'aeskey'} else redact(item)
+            for key, item in value.items()
+        }
+    if isinstance(value, list):
+        return [redact(item) for item in value]
+    return value
+
+
+def summarize_event(event: platform_events.EBAEvent) -> dict:
+    data = {
+        'type': event.type,
+        'adapter_name': event.adapter_name,
+        'timestamp': event.timestamp,
+    }
+    for field in ('message_id', 'chat_id', 'chat_type', 'action', 'data', 'feedback_id', 'feedback_type'):
+        if hasattr(event, field):
+            value = getattr(event, field)
+            if hasattr(value, 'value'):
+                value = value.value
+            data[field] = redact(value)
+    if hasattr(event, 'sender') and event.sender is not None:
+        data['sender'] = event.sender.model_dump()
+    if hasattr(event, 'group') and event.group is not None:
+        data['group'] = event.group.model_dump()
+    if hasattr(event, 'message_chain') and event.message_chain is not None:
+        data['message_chain'] = event.message_chain.model_dump()
+    return data
+
+
+def record_api(results: list[dict[str, Any]], name: str, ok: bool, result: Any = None, error: Exception | None = None):
+    entry = {'name': name, 'ok': ok}
+    if result is not None:
+        entry['result'] = redact(result)
+    if error is not None:
+        entry['error'] = repr(error)
+    results.append(entry)
+    print('WECOMBOT_EBA_API', json.dumps(entry, ensure_ascii=False, default=str))
+
+
+async def run_api(results: list[dict[str, Any]], name: str, func):
+    try:
+        result = await func()
+        record_api(results, name, True, result)
+        return result
+    except Exception as exc:
+        record_api(results, name, False, error=exc)
+        return None
+
+
+def config_from_env(enable_webhook: bool) -> dict:
+    config = {
+        'BotId': os.getenv('WECOMBOT_BOT_ID', ''),
+        'robot_name': os.getenv('WECOMBOT_ROBOT_NAME', ''),
+        'enable-webhook': enable_webhook,
+        'Secret': os.getenv('WECOMBOT_SECRET', ''),
+        'Token': os.getenv('WECOMBOT_TOKEN', ''),
+        'EncodingAESKey': os.getenv('WECOMBOT_ENCODING_AES_KEY', ''),
+        'Corpid': os.getenv('WECOMBOT_CORPID', ''),
+        'enable-stream-reply': os.getenv('WECOMBOT_ENABLE_STREAM_REPLY', '1') != '0',
+    }
+    required = ['BotId', 'Secret'] if not enable_webhook else ['Token', 'EncodingAESKey', 'Corpid']
+    missing = [key for key in required if not config.get(key)]
+    if missing:
+        raise RuntimeError(f'Missing required WeComBot env vars for fields: {missing}')
+    return config
+
+
+async def run_probe(args: argparse.Namespace):
+    adapter = WecomBotAdapter(config_from_env(args.webhook), ProbeLogger())
+    events: list[platform_events.EBAEvent] = []
+    api_results: list[dict[str, Any]] = []
+    first_message = asyncio.Event()
+    log_path = Path(args.log)
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+
+    async def listener(event, adapter):
+        events.append(event)
+        with log_path.open('a', encoding='utf-8') as fp:
+            fp.write(json.dumps(summarize_event(event), ensure_ascii=False, default=str) + '\n')
+        print('WECOMBOT_EBA_EVENT', json.dumps(summarize_event(event), ensure_ascii=False, default=str))
+        if isinstance(event, platform_events.MessageReceivedEvent):
+            first_message.set()
+
+    adapter.register_listener(platform_events.EBAEvent, listener)
+
+    run_task = None
+    server_task = None
+    if args.webhook:
+        app = Quart(__name__)
+
+        @app.route(args.path, methods=['GET', 'POST'])
+        async def callback():
+            return await adapter.handle_unified_webhook(args.bot_uuid, '', request)
+
+        server_task = asyncio.create_task(app.run_task(host=args.host, port=args.port))
+        print(f'READY: configure WeComBot callback URL to http://{args.host}:{args.port}{args.path}')
+    else:
+        run_task = asyncio.create_task(adapter.run_async())
+        print('READY: WeComBot WebSocket long connection started; no webhook URL is required.')
+
+    try:
+        print('READY: send a real WeComBot message to the bot now.')
+        await asyncio.wait_for(first_message.wait(), timeout=args.timeout)
+
+        source = next(event for event in events if isinstance(event, platform_events.MessageReceivedEvent))
+
+        if not args.skip_api:
+            await run_api(
+                api_results,
+                'reply_message:text',
+                lambda: adapter.reply_message(
+                    source,
+                    platform_message.MessageChain([platform_message.Plain(text='WeComBot EBA probe reply')]),
+                ),
+            )
+            if not args.webhook:
+                await run_api(
+                    api_results,
+                    'send_message:text',
+                    lambda: adapter.send_message(
+                        'group' if source.chat_type.value == 'group' else 'person',
+                        source.chat_id,
+                        platform_message.MessageChain([platform_message.Plain(text='WeComBot EBA probe send')]),
+                    ),
+                )
+            await run_api(api_results, 'get_message', lambda: adapter.get_message(source.chat_type.value, source.chat_id, source.message_id))
+            await run_api(api_results, 'get_user_info', lambda: adapter.get_user_info(source.sender.id))
+            if source.group:
+                await run_api(api_results, 'get_group_info', lambda: adapter.get_group_info(source.group.id))
+                await run_api(api_results, 'get_group_member_list', lambda: adapter.get_group_member_list(source.group.id))
+            await run_api(api_results, 'call_platform_api:is_websocket_mode', lambda: adapter.call_platform_api('is_websocket_mode', {}))
+            await run_api(
+                api_results,
+                'call_platform_api:get_stream_session_status',
+                lambda: adapter.call_platform_api('get_stream_session_status', {'message_id': source.message_id}),
+            )
+
+        summary = {
+            'events': [event.type for event in events],
+            'api_results': api_results,
+            'log_path': str(log_path),
+            'mode': 'webhook' if args.webhook else 'websocket',
+        }
+        print('WECOMBOT_EBA_SUMMARY', json.dumps(summary, ensure_ascii=False, default=str))
+        return summary
+    finally:
+        if server_task:
+            server_task.cancel()
+        if run_task:
+            run_task.cancel()
+        await adapter.kill()
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Live WeComBot EBA adapter probe.')
+    parser.add_argument('--webhook', action='store_true', help='Use webhook mode. Default is WebSocket long connection mode.')
+    parser.add_argument('--host', default='0.0.0.0')
+    parser.add_argument('--port', type=int, default=5313)
+    parser.add_argument('--path', default='/wecombot/callback')
+    parser.add_argument('--timeout', type=int, default=180)
+    parser.add_argument('--bot-uuid', default='wecombot-eba-live-probe')
+    parser.add_argument('--log', default='data/temp/wecombot_eba_live_probe.jsonl')
+    parser.add_argument('--skip-api', action='store_true')
+    args = parser.parse_args()
+    asyncio.run(run_probe(args))
+
+
+if __name__ == '__main__':
+    main()

tests/unit_tests/pipeline/test_preproc_media_fallback.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from datetime import datetime
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, Mock
+
+import pytest
+
+from langbot_plugin.api.entities.builtin.platform import message as platform_message
+
+
+def _conversation():
+    prompt = Mock()
+    prompt.messages = []
+    prompt.copy = Mock(return_value=Mock(messages=[]))
+
+    return SimpleNamespace(
+        uuid='conversation-uuid',
+        create_time=datetime.now(),
+        update_time=datetime.now(),
+        prompt=prompt,
+        messages=[],
+    )
+
+
+def _prompt_preprocessing_context():
+    ctx = Mock()
+    ctx.event.default_prompt = []
+    ctx.event.prompt = []
+    return ctx
+
+
+@pytest.mark.asyncio
+async def test_preprocessor_keeps_image_placeholder_for_text_only_local_agent(mock_app, sample_query):
+    model = Mock()
+    model.model_entity.uuid = 'text-only-model'
+    model.model_entity.abilities = []
+
+    mock_app.model_mgr.get_model_by_uuid = AsyncMock(return_value=model)
+    mock_app.sess_mgr.get_session = AsyncMock(
+        return_value=SimpleNamespace(launcher_type=sample_query.launcher_type, launcher_id=sample_query.launcher_id)
+    )
+    mock_app.sess_mgr.get_conversation = AsyncMock(return_value=_conversation())
+    mock_app.plugin_connector.emit_event = AsyncMock(return_value=_prompt_preprocessing_context())
+
+    sample_query.pipeline_config = {
+        'ai': {
+            'runner': {'runner': 'local-agent'},
+            'local-agent': {'model': {'primary': 'text-only-model', 'fallbacks': []}, 'prompt': []},
+        },
+        'trigger': {'misc': {'combine-quote-message': False}},
+        'output': {'misc': {'exception-handling': 'show-hint'}},
+    }
+    sample_query.message_chain = platform_message.MessageChain(
+        [platform_message.Image(base64='data:image/png;base64,AAAA')]
+    )
+    sample_query.messages = []
+    sample_query.variables = {}
+
+    from importlib import import_module
+
+    import_module('langbot.pkg.pipeline.pipelinemgr')
+    preproc_module = import_module('langbot.pkg.pipeline.preproc.preproc')
+    result = await preproc_module.PreProcessor(mock_app).process(sample_query, 'PreProcessor')
+    content = result.new_query.user_message.content
+
+    assert len(content) == 1
+    assert content[0].type == 'text'
+    assert content[0].text == '[Image]'
+    assert result.new_query.variables['user_message_text'] == '[Image]'

tests/unit_tests/platform/test_wecom_eba_adapter.py

@@ -0,0 +1,235 @@
+from __future__ import annotations
+
+import pathlib
+from unittest.mock import AsyncMock, patch
+
+import pytest
+import yaml
+
+from langbot.libs.wecom_api.api import WecomClient
+from langbot.libs.wecom_api.wecomevent import WecomEvent
+from langbot.pkg.platform.adapters.wecom.adapter import WecomAdapter
+from langbot.pkg.platform.adapters.wecom.event_converter import WecomEventConverter
+from langbot.pkg.platform.adapters.wecom.message_converter import WecomMessageConverter, split_string_by_bytes
+from langbot.pkg.platform.adapters.wecom.platform_api import PLATFORM_API_MAP
+from langbot_plugin.api.definition.abstract.platform.event_logger import AbstractEventLogger
+from langbot_plugin.api.entities.builtin.platform import entities as platform_entities
+from langbot_plugin.api.entities.builtin.platform import events as platform_events
+from langbot_plugin.api.entities.builtin.platform import message as platform_message
+
+
+class DummyLogger(AbstractEventLogger):
+    async def info(self, text, images=None, message_session_id=None, no_throw=True):
+        pass
+
+    async def debug(self, text, images=None, message_session_id=None, no_throw=True):
+        pass
+
+    async def warning(self, text, images=None, message_session_id=None, no_throw=True):
+        pass
+
+    async def error(self, text, images=None, message_session_id=None, no_throw=True):
+        pass
+
+
+class DummyWecomClient(WecomClient):
+    def __init__(self, *args, **kwargs):
+        self.corpid = kwargs['corpid']
+        self.secret = kwargs['secret']
+        self.token = kwargs['token']
+        self.aes = kwargs['EncodingAESKey']
+        self.secret_for_contacts = kwargs.get('contacts_secret', '')
+        self.base_url = kwargs.get('api_base_url', 'https://qyapi.weixin.qq.com/cgi-bin')
+        self.logger = kwargs.get('logger')
+        self.access_token = ''
+        self._message_handlers = {}
+        self.get_media_id = AsyncMock(return_value='media-id')
+        self.send_private_msg = AsyncMock()
+        self.send_image = AsyncMock()
+        self.send_voice = AsyncMock()
+        self.send_file = AsyncMock()
+        self.get_user_info = AsyncMock(return_value={'userid': 'user-1', 'name': 'Alice', 'alias': 'alice'})
+        self.check_access_token = AsyncMock(return_value=True)
+        self.get_access_token = AsyncMock(return_value='access-token')
+        self.send_to_all = AsyncMock()
+        self.handle_unified_webhook = AsyncMock(return_value='success')
+
+    def on_message(self, msg_type: str):
+        def decorator(func):
+            self._message_handlers.setdefault(msg_type, []).append(func)
+            return func
+
+        return decorator
+
+
+def manifest() -> dict:
+    manifest_path = (
+        pathlib.Path(__file__).parents[3]
+        / 'src'
+        / 'langbot'
+        / 'pkg'
+        / 'platform'
+        / 'adapters'
+        / 'wecom'
+        / 'manifest.yaml'
+    )
+    return yaml.safe_load(manifest_path.read_text())
+
+
+def make_adapter() -> WecomAdapter:
+    config = {
+        'corpid': 'corp-id',
+        'secret': 'secret',
+        'token': 'token',
+        'EncodingAESKey': 'encoding-key',
+        'contacts_secret': 'contacts-secret',
+        'api_base_url': 'https://qyapi.weixin.qq.com/cgi-bin',
+    }
+    with patch('langbot.pkg.platform.adapters.wecom.adapter.WecomClient', DummyWecomClient):
+        return WecomAdapter(config, DummyLogger())
+
+
+def wecom_event(**overrides) -> WecomEvent:
+    payload = {
+        'ToUserName': overrides.get('to_user', 'corp-id'),
+        'FromUserName': overrides.get('from_user', 'user-1'),
+        'CreateTime': overrides.get('create_time', 1_714_000_000),
+        'MsgType': overrides.get('msg_type', 'text'),
+        'Content': overrides.get('content', 'hello'),
+        'MsgId': overrides.get('message_id', 12345),
+        'AgentID': overrides.get('agent_id', 1000002),
+    }
+    if payload['MsgType'] == 'image':
+        payload['MediaId'] = overrides.get('media_id', 'media-id')
+        payload['PicUrl'] = overrides.get('picurl', 'https://example.test/a.png')
+    return WecomEvent.from_payload(payload)
+
+
+def test_wecom_supported_events_match_manifest():
+    assert make_adapter().get_supported_events() == manifest()['spec']['supported_events']
+
+
+def test_wecom_supported_apis_match_manifest():
+    supported_apis = make_adapter().get_supported_apis()
+    manifest_apis = manifest()['spec']['supported_apis']
+
+    assert supported_apis == manifest_apis['required'] + manifest_apis['optional']
+
+
+def test_wecom_platform_api_map_matches_manifest():
+    manifest_actions = {item['action'] for item in manifest()['spec']['platform_specific_apis']}
+
+    assert set(PLATFORM_API_MAP) == manifest_actions
+
+
+def test_wecom_split_string_by_bytes_keeps_multibyte_boundaries():
+    parts = split_string_by_bytes('你好hello', limit=7)
+
+    assert ''.join(parts) == '你好hello'
+    assert all(len(part.encode('utf-8')) <= 7 for part in parts)
+
+
+@pytest.mark.asyncio
+async def test_wecom_message_converter_maps_outbound_components():
+    adapter = make_adapter()
+    content = await WecomMessageConverter.yiri2target(
+        platform_message.MessageChain(
+            [
+                platform_message.Plain(text='hi'),
+                platform_message.Image(base64='data:image/png;base64,AAAA'),
+                platform_message.Voice(base64='data:audio/mp3;base64,BBBB'),
+                platform_message.File(name='doc.txt', base64='Q0NDQw=='),
+                platform_message.Quote(
+                    id='origin',
+                    origin=platform_message.MessageChain([platform_message.Plain(text='quoted')]),
+                ),
+            ]
+        ),
+        adapter.bot,
+    )
+
+    assert content[0] == {'type': 'text', 'content': 'hi'}
+    assert {'type': 'image', 'media_id': 'media-id'} in content
+    assert {'type': 'voice', 'media_id': 'media-id'} in content
+    assert {'type': 'file', 'media_id': 'media-id'} in content
+    assert {'type': 'text', 'content': '[Quote origin] '} in content
+    assert {'type': 'text', 'content': 'quoted'} in content
+
+
+@pytest.mark.asyncio
+async def test_wecom_event_converter_maps_text_message_to_eba_and_legacy():
+    adapter = make_adapter()
+    event = await WecomEventConverter.target2yiri(wecom_event(), adapter.bot)
+
+    assert isinstance(event, platform_events.MessageReceivedEvent)
+    assert event.adapter_name == 'wecom-eba'
+    assert event.chat_type == platform_entities.ChatType.PRIVATE
+    assert event.chat_id == 'user-1|1000002'
+    assert event.sender.nickname == 'Alice'
+    assert str(event.message_chain) == 'hello'
+
+    legacy = await WecomEventConverter.target2legacy(wecom_event(), adapter.bot)
+    assert isinstance(legacy, platform_events.FriendMessage)
+    assert legacy.sender.id == 'user-1'
+    assert str(legacy.message_chain) == 'hello'
+
+
+@pytest.mark.asyncio
+async def test_wecom_event_converter_maps_image_message_to_eba():
+    adapter = make_adapter()
+
+    with patch(
+        'langbot.pkg.platform.adapters.wecom.message_converter.image.get_wecom_image_base64',
+        AsyncMock(return_value=('AAAA', 'png')),
+    ):
+        event = await WecomEventConverter.target2yiri(
+            wecom_event(msg_type='image', content=None, picurl='https://example.test/a.png'),
+            adapter.bot,
+        )
+
+    assert isinstance(event, platform_events.MessageReceivedEvent)
+    assert event.adapter_name == 'wecom-eba'
+    assert event.message_id == 12345
+    assert isinstance(event.message_chain[1], platform_message.Image)
+    assert event.message_chain[1].base64 == 'data:image/png;base64,AAAA'
+
+
+@pytest.mark.asyncio
+async def test_wecom_adapter_dispatches_and_caches_message_event():
+    adapter = make_adapter()
+    calls: list[platform_events.Event] = []
+
+    async def listener(event, adapter):
+        calls.append(event)
+
+    adapter.register_listener(platform_events.MessageReceivedEvent, listener)
+    await adapter._handle_native_event(wecom_event())
+
+    assert len(calls) == 1
+    received = calls[0]
+    assert isinstance(received, platform_events.MessageReceivedEvent)
+    assert adapter.bot_account_id == 'corp-id'
+    assert received.chat_id == 'user-1|1000002'
+    assert await adapter.get_message('private', 'user-1|1000002', 12345) == received
+    assert (await adapter.get_user_info('user-1')).nickname == 'Alice'
+
+
+@pytest.mark.asyncio
+async def test_wecom_send_reply_and_platform_api_use_underlying_client():
+    adapter = make_adapter()
+    message = platform_message.MessageChain([platform_message.Plain(text='hello')])
+
+    await adapter.send_message('person', 'user-1|1000002', message)
+    adapter.bot.send_private_msg.assert_awaited_once_with('user-1', 1000002, 'hello')
+
+    source_event = await WecomEventConverter.target2yiri(wecom_event(), adapter.bot)
+    await adapter.reply_message(source_event, message)
+    assert adapter.bot.send_private_msg.await_count == 2
+
+    token_status = await adapter.call_platform_api('check_access_token', {})
+    user_info = await adapter.call_platform_api('get_user_info', {'user_id': 'user-1'})
+    sent_all = await adapter.call_platform_api('send_to_all', {'content': 'notice', 'agent_id': 1000002})
+
+    assert token_status == {'valid': True}
+    assert user_info['name'] == 'Alice'
+    assert sent_all == {'ok': True}

tests/unit_tests/platform/test_wecombot_eba_adapter.py

@@ -0,0 +1,274 @@
+from __future__ import annotations
+
+import pathlib
+from unittest.mock import AsyncMock, patch
+
+import pytest
+import yaml
+
+from langbot.libs.wecom_ai_bot_api.wecombotevent import WecomBotEvent
+from langbot.pkg.platform.adapters.wecombot.adapter import WecomBotAdapter
+from langbot.pkg.platform.adapters.wecombot.event_converter import WecomBotEventConverter
+from langbot.pkg.platform.adapters.wecombot.message_converter import WecomBotMessageConverter
+from langbot.pkg.platform.adapters.wecombot.platform_api import PLATFORM_API_MAP
+from langbot_plugin.api.definition.abstract.platform.event_logger import AbstractEventLogger
+from langbot_plugin.api.entities.builtin.platform import entities as platform_entities
+from langbot_plugin.api.entities.builtin.platform import events as platform_events
+from langbot_plugin.api.entities.builtin.platform import message as platform_message
+from langbot_plugin.api.entities.builtin.platform.errors import NotSupportedError
+
+
+class DummyLogger(AbstractEventLogger):
+    async def info(self, text, images=None, message_session_id=None, no_throw=True):
+        pass
+
+    async def debug(self, text, images=None, message_session_id=None, no_throw=True):
+        pass
+
+    async def warning(self, text, images=None, message_session_id=None, no_throw=True):
+        pass
+
+    async def error(self, text, images=None, message_session_id=None, no_throw=True):
+        pass
+
+
+class DummyWecomBotWsClient:
+    def __init__(self, *args, **kwargs):
+        self.bot_id = kwargs['bot_id']
+        self.secret = kwargs['secret']
+        self.encoding_aes_key = kwargs.get('encoding_aes_key', '')
+        self._message_handlers = {}
+        self.connect = AsyncMock()
+        self.disconnect = AsyncMock()
+        self.send_message = AsyncMock(return_value={'ok': True})
+        self.reply_text = AsyncMock(return_value={'reply': True})
+        self.push_stream_chunk = AsyncMock(return_value=True)
+        self.set_message = AsyncMock(return_value={'set': True})
+
+    def on_message(self, msg_type: str):
+        def decorator(func):
+            self._message_handlers.setdefault(msg_type, []).append(func)
+            return func
+
+        return decorator
+
+    def on_feedback(self):
+        def decorator(func):
+            self._message_handlers.setdefault('feedback', []).append(func)
+            return func
+
+        return decorator
+
+
+class DummyWecomBotClient(DummyWecomBotWsClient):
+    def __init__(self, *args, **kwargs):
+        self.Token = kwargs['Token']
+        self.EnCodingAESKey = kwargs['EnCodingAESKey']
+        self.Corpid = kwargs['Corpid']
+        self._message_handlers = {}
+        self.handle_unified_webhook = AsyncMock(return_value='success')
+        self.push_stream_chunk = AsyncMock(return_value=True)
+        self.set_message = AsyncMock(return_value={'set': True})
+
+
+def manifest() -> dict:
+    manifest_path = (
+        pathlib.Path(__file__).parents[3]
+        / 'src'
+        / 'langbot'
+        / 'pkg'
+        / 'platform'
+        / 'adapters'
+        / 'wecombot'
+        / 'manifest.yaml'
+    )
+    return yaml.safe_load(manifest_path.read_text())
+
+
+def make_adapter(enable_webhook: bool = False) -> WecomBotAdapter:
+    config = {
+        'BotId': 'bot-id',
+        'robot_name': 'EBA Bot',
+        'enable-webhook': enable_webhook,
+        'Secret': 'secret',
+        'Token': 'token',
+        'EncodingAESKey': 'encoding-key',
+        'Corpid': 'corp-id',
+        'enable-stream-reply': True,
+    }
+    with (
+        patch('langbot.pkg.platform.adapters.wecombot.adapter.WecomBotWsClient', DummyWecomBotWsClient),
+        patch('langbot.pkg.platform.adapters.wecombot.adapter.WecomBotClient', DummyWecomBotClient),
+    ):
+        return WecomBotAdapter(config, DummyLogger())
+
+
+def wecombot_event(**overrides) -> WecomBotEvent:
+    event_type = overrides.get('type', 'single')
+    payload = {
+        'type': event_type,
+        'msgtype': overrides.get('msgtype', 'text'),
+        'msgid': overrides.get('message_id', 'msg-1'),
+        'userid': overrides.get('userid', 'user-1'),
+        'username': overrides.get('username', 'Alice'),
+        'content': overrides.get('content', 'hello'),
+        'aibotid': overrides.get('aibotid', 'bot-id'),
+        'req_id': overrides.get('req_id', 'req-1'),
+        'stream_id': overrides.get('stream_id', 'stream-1'),
+    }
+    if event_type == 'group':
+        payload.update({'chatid': overrides.get('chatid', 'group-1'), 'chatname': overrides.get('chatname', 'Group')})
+    if payload['msgtype'] == 'image':
+        payload['images'] = overrides.get('images', ['data:image/png;base64,AAAA'])
+        payload['content'] = overrides.get('content', '')
+    if payload['msgtype'] == 'file':
+        payload['file'] = overrides.get('file', {'download_url': 'https://example.test/a.txt', 'filename': 'a.txt'})
+        payload['content'] = overrides.get('content', '')
+    if payload['msgtype'] == 'voice':
+        payload['voice'] = overrides.get('voice', {'base64': 'BBBB'})
+        payload['content'] = overrides.get('content', '')
+    if 'quote' in overrides:
+        payload['quote'] = overrides['quote']
+    return WecomBotEvent(payload)
+
+
+def test_wecombot_supported_events_match_manifest():
+    assert make_adapter().get_supported_events() == manifest()['spec']['supported_events']
+
+
+def test_wecombot_supported_apis_match_manifest():
+    supported_apis = make_adapter().get_supported_apis()
+    manifest_apis = manifest()['spec']['supported_apis']
+
+    assert supported_apis == manifest_apis['required'] + manifest_apis['optional']
+
+
+def test_wecombot_platform_api_map_matches_manifest():
+    manifest_actions = {item['action'] for item in manifest()['spec']['platform_specific_apis']}
+
+    assert set(PLATFORM_API_MAP) == manifest_actions
+
+
+@pytest.mark.asyncio
+async def test_wecombot_message_converter_maps_outbound_components_to_markdown_text():
+    content = await WecomBotMessageConverter.yiri2target(
+        platform_message.MessageChain(
+            [
+                platform_message.Plain(text='hi'),
+                platform_message.At(target='user-1', display='Alice'),
+                platform_message.Image(base64='data:image/png;base64,AAAA'),
+                platform_message.File(name='a.txt', url='https://example.test/a.txt'),
+                platform_message.Quote(
+                    id='origin',
+                    origin=platform_message.MessageChain([platform_message.Plain(text='quoted')]),
+                ),
+            ]
+        )
+    )
+
+    assert 'hi' in content
+    assert '@Alice' in content
+    assert '[Image]' in content
+    assert '[File: a.txt]' in content
+    assert '[Quote origin]' in content
+    assert 'quoted' in content
+
+
+@pytest.mark.asyncio
+async def test_wecombot_event_converter_maps_private_and_group_messages_to_eba():
+    private_event = await WecomBotEventConverter(bot_name='EBA Bot').target2yiri(
+        wecombot_event(content='@EBA Bot hello')
+    )
+    group_event = await WecomBotEventConverter(bot_name='EBA Bot').target2yiri(
+        wecombot_event(type='group', content='@EBA Bot group hello')
+    )
+
+    assert isinstance(private_event, platform_events.MessageReceivedEvent)
+    assert private_event.adapter_name == 'wecombot-eba'
+    assert private_event.chat_type == platform_entities.ChatType.PRIVATE
+    assert private_event.chat_id == 'user-1'
+    assert str(private_event.message_chain) == 'hello'
+
+    assert isinstance(group_event, platform_events.MessageReceivedEvent)
+    assert group_event.chat_type == platform_entities.ChatType.GROUP
+    assert group_event.chat_id == 'group-1'
+    assert group_event.group.name == 'Group'
+    assert isinstance(group_event.message_chain[1], platform_message.At)
+
+
+@pytest.mark.asyncio
+async def test_wecombot_event_converter_maps_media_and_quote_components():
+    event = await WecomBotEventConverter().target2yiri(
+        wecombot_event(
+            msgtype='image',
+            quote={
+                'content': 'quoted',
+                'file': {'download_url': 'https://example.test/q.txt', 'filename': 'q.txt'},
+            },
+        )
+    )
+
+    assert isinstance(event, platform_events.MessageReceivedEvent)
+    assert any(isinstance(component, platform_message.Image) for component in event.message_chain)
+    quote = next(component for component in event.message_chain if isinstance(component, platform_message.Quote))
+    assert any(isinstance(component, platform_message.File) for component in quote.origin)
+
+
+@pytest.mark.asyncio
+async def test_wecombot_adapter_dispatches_eba_and_legacy_and_caches_message_event():
+    adapter = make_adapter()
+    eba_calls: list[platform_events.Event] = []
+    legacy_calls: list[platform_events.Event] = []
+
+    async def eba_listener(event, adapter):
+        eba_calls.append(event)
+
+    async def legacy_listener(event, adapter):
+        legacy_calls.append(event)
+
+    adapter.register_listener(platform_events.MessageReceivedEvent, eba_listener)
+    adapter.register_listener(platform_events.FriendMessage, legacy_listener)
+    await adapter._handle_native_event(wecombot_event())
+
+    assert len(eba_calls) == 1
+    assert len(legacy_calls) == 1
+    received = eba_calls[0]
+    assert isinstance(received, platform_events.MessageReceivedEvent)
+    assert await adapter.get_message('private', 'user-1', 'msg-1') == received
+    assert (await adapter.get_user_info('user-1')).nickname == 'Alice'
+
+
+@pytest.mark.asyncio
+async def test_wecombot_send_reply_feedback_and_platform_api_use_underlying_client():
+    adapter = make_adapter()
+    message = platform_message.MessageChain([platform_message.Plain(text='hello')])
+
+    await adapter.send_message('person', 'user-1', message)
+    adapter.bot.send_message.assert_awaited_once_with('user-1', 'hello')
+
+    source_event = await WecomBotEventConverter().target2yiri(wecombot_event())
+    await adapter.reply_message(source_event, message)
+    adapter.bot.reply_text.assert_awaited_once_with('req-1', 'hello')
+
+    await adapter.reply_message_chunk(source_event, None, message, is_final=True)
+    adapter.bot.push_stream_chunk.assert_awaited_once_with('msg-1', 'hello', is_final=True)
+
+    platform_status = await adapter.call_platform_api('is_websocket_mode', {})
+    assert platform_status == {'websocket': True}
+
+    feedback_calls: list[platform_events.Event] = []
+
+    async def feedback_listener(event, adapter):
+        feedback_calls.append(event)
+
+    adapter.register_listener(platform_events.FeedbackReceivedEvent, feedback_listener)
+    await adapter._handle_feedback(feedback_id='fb-1', feedback_type=1, inaccurate_reasons=[1, 2], session=None)
+    assert isinstance(feedback_calls[0], platform_events.FeedbackReceivedEvent)
+    assert feedback_calls[0].inaccurate_reasons == ['1', '2']
+
+
+@pytest.mark.asyncio
+async def test_wecombot_webhook_mode_rejects_proactive_send():
+    adapter = make_adapter(enable_webhook=True)
+    with pytest.raises(NotSupportedError):
+        await adapter.send_message('person', 'user-1', platform_message.MessageChain([platform_message.Plain(text='hi')]))